/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = 'regional';
  @endpointMap = {
    ap-northeast-1 = 'green.ap-southeast-1.aliyuncs.com',
    ap-south-1 = 'green.ap-southeast-1.aliyuncs.com',
    ap-southeast-2 = 'green.ap-southeast-1.aliyuncs.com',
    ap-southeast-3 = 'green.ap-southeast-1.aliyuncs.com',
    ap-southeast-5 = 'green.ap-southeast-1.aliyuncs.com',
    cn-chengdu = 'green.aliyuncs.com',
    cn-hongkong = 'green.aliyuncs.com',
    cn-huhehaote = 'green.aliyuncs.com',
    cn-qingdao = 'green.aliyuncs.com',
    cn-zhangjiakou = 'green.aliyuncs.com',
    eu-central-1 = 'green.ap-southeast-1.aliyuncs.com',
    eu-west-1 = 'green.ap-southeast-1.aliyuncs.com',
    me-east-1 = 'green.ap-southeast-1.aliyuncs.com',
    us-east-1 = 'green.ap-southeast-1.aliyuncs.com',
    cn-hangzhou-finance = 'green.aliyuncs.com',
    cn-shenzhen-finance-1 = 'green.aliyuncs.com',
    cn-shanghai-finance-1 = 'green.aliyuncs.com',
    cn-north-2-gov-1 = 'green.aliyuncs.com',
  };

  checkConfig(config);
  @endpoint = getEndpoint('green', @regionId, @endpointRule, @network, @suffix, @endpointMap, @endpoint);
}

function getEndpoint(productId: string, regionId: string, endpointRule: string, network: string, suffix: string, endpointMap: map[string]string, endpoint: string) throws: string{
  if (!Util.empty(endpoint)) {
    return endpoint;
  }
  
  if (!Util.isUnset(endpointMap) && !Util.empty(endpointMap[regionId])) {
    return endpointMap[regionId];
  }
  return EndpointUtil.getEndpointRules(productId, regionId, endpointRule, network, suffix);
}

model AuditItemSubmitRequest {
  data?: [ 
    {
      customResult?: string(name='CustomResult'),
      customRiskType?: string(name='CustomRiskType'),
      id?: long(name='Id'),
    }
  ](name='Data'),
}

model AuditItemSubmitResponseBody = {
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model AuditItemSubmitResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: AuditItemSubmitResponseBody(name='body'),
}

async function auditItemSubmitWithOptions(request: AuditItemSubmitRequest, runtime: Util.RuntimeOptions): AuditItemSubmitResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.data)) {
    query['Data'] = request.data;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AuditItemSubmit',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function auditItemSubmit(request: AuditItemSubmitRequest): AuditItemSubmitResponse {
  var runtime = new Util.RuntimeOptions{};
  return auditItemSubmitWithOptions(request, runtime);
}

model CreatCustomOcrTemplateRequest {
  imgUrl?: string(name='ImgUrl'),
  name?: string(name='Name'),
  recognizeArea?: string(name='RecognizeArea'),
  referArea?: string(name='ReferArea'),
}

model CreatCustomOcrTemplateResponseBody = {
  requestId?: string(name='RequestId'),
}

model CreatCustomOcrTemplateResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreatCustomOcrTemplateResponseBody(name='body'),
}

async function creatCustomOcrTemplateWithOptions(request: CreatCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): CreatCustomOcrTemplateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.imgUrl)) {
    query['ImgUrl'] = request.imgUrl;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.recognizeArea)) {
    query['RecognizeArea'] = request.recognizeArea;
  }
  if (!Util.isUnset(request.referArea)) {
    query['ReferArea'] = request.referArea;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreatCustomOcrTemplate',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function creatCustomOcrTemplate(request: CreatCustomOcrTemplateRequest): CreatCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return creatCustomOcrTemplateWithOptions(request, runtime);
}

model CreateAuditCallbackRequest {
  callbackSuggestions?: string(name='CallbackSuggestions'),
  callbackTypes?: string(name='CallbackTypes'),
  cryptType?: string(name='CryptType'),
  name?: string(name='Name'),
  url?: string(name='Url'),
}

model CreateAuditCallbackResponseBody = {
  callbackSuggestions?: [ string ](name='CallbackSuggestions'),
  callbackTypes?: [ string ](name='CallbackTypes'),
  createTime?: string(name='CreateTime'),
  cryptType?: string(name='CryptType'),
  id?: long(name='Id'),
  modifiedTime?: string(name='ModifiedTime'),
  name?: string(name='Name'),
  requestId?: string(name='RequestId'),
  seed?: string(name='Seed'),
  url?: string(name='Url'),
}

model CreateAuditCallbackResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateAuditCallbackResponseBody(name='body'),
}

async function createAuditCallbackWithOptions(request: CreateAuditCallbackRequest, runtime: Util.RuntimeOptions): CreateAuditCallbackResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.callbackSuggestions)) {
    query['CallbackSuggestions'] = request.callbackSuggestions;
  }
  if (!Util.isUnset(request.callbackTypes)) {
    query['CallbackTypes'] = request.callbackTypes;
  }
  if (!Util.isUnset(request.cryptType)) {
    query['CryptType'] = request.cryptType;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.url)) {
    query['Url'] = request.url;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateAuditCallback',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createAuditCallback(request: CreateAuditCallbackRequest): CreateAuditCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return createAuditCallbackWithOptions(request, runtime);
}

model CreateBizTypeRequest {
  bizTypeImport?: string(name='BizTypeImport'),
  bizTypeName?: string(name='BizTypeName'),
  citeTemplate?: boolean(name='CiteTemplate'),
  description?: string(name='Description'),
  industryInfo?: string(name='IndustryInfo'),
}

model CreateBizTypeResponseBody = {
  requestId?: string(name='RequestId'),
}

model CreateBizTypeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateBizTypeResponseBody(name='body'),
}

async function createBizTypeWithOptions(request: CreateBizTypeRequest, runtime: Util.RuntimeOptions): CreateBizTypeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypeImport)) {
    query['BizTypeImport'] = request.bizTypeImport;
  }
  if (!Util.isUnset(request.bizTypeName)) {
    query['BizTypeName'] = request.bizTypeName;
  }
  if (!Util.isUnset(request.citeTemplate)) {
    query['CiteTemplate'] = request.citeTemplate;
  }
  if (!Util.isUnset(request.description)) {
    query['Description'] = request.description;
  }
  if (!Util.isUnset(request.industryInfo)) {
    query['IndustryInfo'] = request.industryInfo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateBizType',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createBizType(request: CreateBizTypeRequest): CreateBizTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return createBizTypeWithOptions(request, runtime);
}

model CreateCdiBagRequest {
  clientToken?: string(name='ClientToken'),
  commodityCode?: string(name='CommodityCode'),
  flowOutSpec?: int32(name='FlowOutSpec'),
  orderNum?: int32(name='OrderNum'),
  orderType?: string(name='OrderType'),
  ownerId?: long(name='OwnerId'),
}

model CreateCdiBagResponseBody = {
  code?: string(name='Code'),
  instanceIds?: {
    string?: [ string ](name='String')
  }(name='InstanceIds'),
  message?: string(name='Message'),
  orderId?: string(name='OrderId'),
  requestId?: string(name='RequestId'),
}

model CreateCdiBagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateCdiBagResponseBody(name='body'),
}

async function createCdiBagWithOptions(request: CreateCdiBagRequest, runtime: Util.RuntimeOptions): CreateCdiBagResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.commodityCode)) {
    query['CommodityCode'] = request.commodityCode;
  }
  if (!Util.isUnset(request.flowOutSpec)) {
    query['FlowOutSpec'] = request.flowOutSpec;
  }
  if (!Util.isUnset(request.orderNum)) {
    query['OrderNum'] = request.orderNum;
  }
  if (!Util.isUnset(request.orderType)) {
    query['OrderType'] = request.orderType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateCdiBag',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createCdiBag(request: CreateCdiBagRequest): CreateCdiBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return createCdiBagWithOptions(request, runtime);
}

model CreateCdiBaseBagRequest {
  clientToken?: string(name='ClientToken'),
  commodityCode?: string(name='CommodityCode'),
  duration?: int32(name='Duration'),
  flowOutSpec?: int32(name='FlowOutSpec'),
  orderType?: string(name='OrderType'),
  ownerId?: long(name='OwnerId'),
}

model CreateCdiBaseBagResponseBody = {
  code?: string(name='Code'),
  instanceId?: string(name='InstanceId'),
  message?: string(name='Message'),
  orderId?: string(name='OrderId'),
  requestId?: string(name='RequestId'),
}

model CreateCdiBaseBagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateCdiBaseBagResponseBody(name='body'),
}

async function createCdiBaseBagWithOptions(request: CreateCdiBaseBagRequest, runtime: Util.RuntimeOptions): CreateCdiBaseBagResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.commodityCode)) {
    query['CommodityCode'] = request.commodityCode;
  }
  if (!Util.isUnset(request.duration)) {
    query['Duration'] = request.duration;
  }
  if (!Util.isUnset(request.flowOutSpec)) {
    query['FlowOutSpec'] = request.flowOutSpec;
  }
  if (!Util.isUnset(request.orderType)) {
    query['OrderType'] = request.orderType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateCdiBaseBag',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createCdiBaseBag(request: CreateCdiBaseBagRequest): CreateCdiBaseBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return createCdiBaseBagWithOptions(request, runtime);
}

model CreateImageLibRequest {
  bizTypes?: string(name='BizTypes'),
  category?: string(name='Category'),
  enable?: boolean(name='Enable'),
  name?: string(name='Name'),
  scene?: string(name='Scene'),
  serviceModule?: string(name='ServiceModule'),
  sourceIp?: string(name='SourceIp'),
}

model CreateImageLibResponseBody = {
  id?: long(name='Id'),
  requestId?: string(name='RequestId'),
}

model CreateImageLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateImageLibResponseBody(name='body'),
}

async function createImageLibWithOptions(request: CreateImageLibRequest, runtime: Util.RuntimeOptions): CreateImageLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypes)) {
    query['BizTypes'] = request.bizTypes;
  }
  if (!Util.isUnset(request.category)) {
    query['Category'] = request.category;
  }
  if (!Util.isUnset(request.enable)) {
    query['Enable'] = request.enable;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  if (!Util.isUnset(request.serviceModule)) {
    query['ServiceModule'] = request.serviceModule;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateImageLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createImageLib(request: CreateImageLibRequest): CreateImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return createImageLibWithOptions(request, runtime);
}

model CreateKeywordRequest {
  keywordLibId?: long(name='KeywordLibId'),
  keywords?: string(name='Keywords'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model CreateKeywordResponseBody = {
  invalidKeywordList?: [ string ](name='InvalidKeywordList'),
  requestId?: string(name='RequestId'),
  successCount?: int32(name='SuccessCount'),
  validKeywordList?: [ 
    {
      id?: int32(name='id'),
      keyword?: string(name='keyword'),
    }
  ](name='validKeywordList'),
}

model CreateKeywordResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateKeywordResponseBody(name='body'),
}

async function createKeywordWithOptions(request: CreateKeywordRequest, runtime: Util.RuntimeOptions): CreateKeywordResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.keywordLibId)) {
    query['KeywordLibId'] = request.keywordLibId;
  }
  if (!Util.isUnset(request.keywords)) {
    query['Keywords'] = request.keywords;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateKeyword',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createKeyword(request: CreateKeywordRequest): CreateKeywordResponse {
  var runtime = new Util.RuntimeOptions{};
  return createKeywordWithOptions(request, runtime);
}

model CreateKeywordLibRequest {
  bizTypes?: string(name='BizTypes'),
  category?: string(name='Category'),
  enable?: boolean(name='Enable'),
  lang?: string(name='Lang'),
  language?: string(name='Language'),
  libType?: string(name='LibType'),
  matchMode?: string(name='MatchMode'),
  name?: string(name='Name'),
  resourceType?: string(name='ResourceType'),
  serviceModule?: string(name='ServiceModule'),
  sourceIp?: string(name='SourceIp'),
}

model CreateKeywordLibResponseBody = {
  id?: string(name='Id'),
  requestId?: string(name='RequestId'),
}

model CreateKeywordLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateKeywordLibResponseBody(name='body'),
}

async function createKeywordLibWithOptions(request: CreateKeywordLibRequest, runtime: Util.RuntimeOptions): CreateKeywordLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypes)) {
    query['BizTypes'] = request.bizTypes;
  }
  if (!Util.isUnset(request.category)) {
    query['Category'] = request.category;
  }
  if (!Util.isUnset(request.enable)) {
    query['Enable'] = request.enable;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.language)) {
    query['Language'] = request.language;
  }
  if (!Util.isUnset(request.libType)) {
    query['LibType'] = request.libType;
  }
  if (!Util.isUnset(request.matchMode)) {
    query['MatchMode'] = request.matchMode;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.serviceModule)) {
    query['ServiceModule'] = request.serviceModule;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateKeywordLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createKeywordLib(request: CreateKeywordLibRequest): CreateKeywordLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return createKeywordLibWithOptions(request, runtime);
}

model CreateWebSiteInstanceRequest {
  clientToken?: string(name='ClientToken'),
  duration?: int32(name='Duration'),
  orderNum?: int32(name='OrderNum'),
  orderType?: string(name='OrderType'),
  ownerId?: long(name='OwnerId'),
  pricingCycle?: string(name='PricingCycle'),
}

model CreateWebSiteInstanceResponseBody = {
  code?: string(name='Code'),
  instanceIds?: {
    string?: [ string ](name='String')
  }(name='InstanceIds'),
  message?: string(name='Message'),
  orderId?: string(name='OrderId'),
  requestId?: string(name='RequestId'),
}

model CreateWebSiteInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateWebSiteInstanceResponseBody(name='body'),
}

async function createWebSiteInstanceWithOptions(request: CreateWebSiteInstanceRequest, runtime: Util.RuntimeOptions): CreateWebSiteInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.duration)) {
    query['Duration'] = request.duration;
  }
  if (!Util.isUnset(request.orderNum)) {
    query['OrderNum'] = request.orderNum;
  }
  if (!Util.isUnset(request.orderType)) {
    query['OrderType'] = request.orderType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pricingCycle)) {
    query['PricingCycle'] = request.pricingCycle;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateWebSiteInstance',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createWebSiteInstance(request: CreateWebSiteInstanceRequest): CreateWebSiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return createWebSiteInstanceWithOptions(request, runtime);
}

model CreateWebsiteIndexPageBaselineRequest {
  instanceId?: string(name='InstanceId'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model CreateWebsiteIndexPageBaselineResponseBody = {
  requestId?: string(name='RequestId'),
}

model CreateWebsiteIndexPageBaselineResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: CreateWebsiteIndexPageBaselineResponseBody(name='body'),
}

async function createWebsiteIndexPageBaselineWithOptions(request: CreateWebsiteIndexPageBaselineRequest, runtime: Util.RuntimeOptions): CreateWebsiteIndexPageBaselineResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateWebsiteIndexPageBaseline',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createWebsiteIndexPageBaseline(request: CreateWebsiteIndexPageBaselineRequest): CreateWebsiteIndexPageBaselineResponse {
  var runtime = new Util.RuntimeOptions{};
  return createWebsiteIndexPageBaselineWithOptions(request, runtime);
}

model DeleteBizTypeRequest {
  bizTypeName?: string(name='BizTypeName'),
}

model DeleteBizTypeResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteBizTypeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteBizTypeResponseBody(name='body'),
}

async function deleteBizTypeWithOptions(request: DeleteBizTypeRequest, runtime: Util.RuntimeOptions): DeleteBizTypeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypeName)) {
    query['BizTypeName'] = request.bizTypeName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteBizType',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteBizType(request: DeleteBizTypeRequest): DeleteBizTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteBizTypeWithOptions(request, runtime);
}

model DeleteCustomOcrTemplateRequest {
  ids?: string(name='Ids'),
}

model DeleteCustomOcrTemplateResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteCustomOcrTemplateResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteCustomOcrTemplateResponseBody(name='body'),
}

async function deleteCustomOcrTemplateWithOptions(request: DeleteCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): DeleteCustomOcrTemplateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteCustomOcrTemplate',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteCustomOcrTemplate(request: DeleteCustomOcrTemplateRequest): DeleteCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteCustomOcrTemplateWithOptions(request, runtime);
}

model DeleteImageFromLibRequest {
  ids?: string(name='Ids'),
  sourceIp?: string(name='SourceIp'),
}

model DeleteImageFromLibResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteImageFromLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteImageFromLibResponseBody(name='body'),
}

async function deleteImageFromLibWithOptions(request: DeleteImageFromLibRequest, runtime: Util.RuntimeOptions): DeleteImageFromLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteImageFromLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteImageFromLib(request: DeleteImageFromLibRequest): DeleteImageFromLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteImageFromLibWithOptions(request, runtime);
}

model DeleteImageLibRequest {
  id?: int32(name='Id'),
  sourceIp?: string(name='SourceIp'),
}

model DeleteImageLibResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteImageLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteImageLibResponseBody(name='body'),
}

async function deleteImageLibWithOptions(request: DeleteImageLibRequest, runtime: Util.RuntimeOptions): DeleteImageLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteImageLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteImageLib(request: DeleteImageLibRequest): DeleteImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteImageLibWithOptions(request, runtime);
}

model DeleteKeywordRequest {
  ids?: string(name='Ids'),
  keywordLibId?: string(name='KeywordLibId'),
  keywords?: string(name='Keywords'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DeleteKeywordResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteKeywordResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteKeywordResponseBody(name='body'),
}

async function deleteKeywordWithOptions(request: DeleteKeywordRequest, runtime: Util.RuntimeOptions): DeleteKeywordResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  if (!Util.isUnset(request.keywordLibId)) {
    query['KeywordLibId'] = request.keywordLibId;
  }
  if (!Util.isUnset(request.keywords)) {
    query['Keywords'] = request.keywords;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteKeyword',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteKeyword(request: DeleteKeywordRequest): DeleteKeywordResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteKeywordWithOptions(request, runtime);
}

model DeleteKeywordLibRequest {
  id?: int32(name='Id'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DeleteKeywordLibResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteKeywordLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteKeywordLibResponseBody(name='body'),
}

async function deleteKeywordLibWithOptions(request: DeleteKeywordLibRequest, runtime: Util.RuntimeOptions): DeleteKeywordLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteKeywordLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteKeywordLib(request: DeleteKeywordLibRequest): DeleteKeywordLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteKeywordLibWithOptions(request, runtime);
}

model DeleteNotificationContactsRequest {
  contactTypes?: string(name='ContactTypes'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DeleteNotificationContactsResponseBody = {
  requestId?: string(name='RequestId'),
}

model DeleteNotificationContactsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DeleteNotificationContactsResponseBody(name='body'),
}

async function deleteNotificationContactsWithOptions(request: DeleteNotificationContactsRequest, runtime: Util.RuntimeOptions): DeleteNotificationContactsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.contactTypes)) {
    query['ContactTypes'] = request.contactTypes;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteNotificationContacts',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteNotificationContacts(request: DeleteNotificationContactsRequest): DeleteNotificationContactsResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteNotificationContactsWithOptions(request, runtime);
}

model DescribeAppInfoRequest {
  currentPage?: int32(name='CurrentPage'),
  lang?: string(name='Lang'),
  pageSize?: int32(name='PageSize'),
  platform?: string(name='Platform'),
  sourceIp?: string(name='SourceIp'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeAppInfoResponseBody = {
  appInfoList?: [ 
    {
      debugPackageInfo?: {
        version?: string(name='Version'),
      }(name='DebugPackageInfo'),
      endDate?: string(name='EndDate'),
      icon?: string(name='Icon'),
      id?: long(name='Id'),
      name?: string(name='Name'),
      packageInfo?: {
        version?: string(name='Version'),
      }(name='PackageInfo'),
      packageName?: string(name='PackageName'),
      startDate?: string(name='StartDate'),
      type?: int32(name='Type'),
    }
  ](name='AppInfoList'),
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeAppInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAppInfoResponseBody(name='body'),
}

async function describeAppInfoWithOptions(request: DescribeAppInfoRequest, runtime: Util.RuntimeOptions): DescribeAppInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.platform)) {
    query['Platform'] = request.platform;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAppInfo',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAppInfo(request: DescribeAppInfoRequest): DescribeAppInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAppInfoWithOptions(request, runtime);
}

model DescribeAuditCallbackResponseBody = {
  callback?: string(name='Callback'),
  cryptType?: int32(name='CryptType'),
  requestId?: string(name='RequestId'),
  seed?: string(name='Seed'),
}

model DescribeAuditCallbackResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAuditCallbackResponseBody(name='body'),
}

async function describeAuditCallbackWithOptions(runtime: Util.RuntimeOptions): DescribeAuditCallbackResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'DescribeAuditCallback',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAuditCallback(): DescribeAuditCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditCallbackWithOptions(runtime);
}

model DescribeAuditCallbackListResponseBody = {
  callbackList?: [ 
    {
      callbackSuggestions?: [ string ](name='CallbackSuggestions'),
      callbackTypes?: [ string ](name='CallbackTypes'),
      createTime?: string(name='CreateTime'),
      cryptType?: string(name='CryptType'),
      id?: long(name='Id'),
      modifiedTime?: string(name='ModifiedTime'),
      name?: string(name='Name'),
      seed?: string(name='Seed'),
      url?: string(name='Url'),
    }
  ](name='CallbackList'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeAuditCallbackListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAuditCallbackListResponseBody(name='body'),
}

async function describeAuditCallbackListWithOptions(runtime: Util.RuntimeOptions): DescribeAuditCallbackListResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'DescribeAuditCallbackList',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAuditCallbackList(): DescribeAuditCallbackListResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditCallbackListWithOptions(runtime);
}

model DescribeAuditContentRequest {
  auditResult?: string(name='AuditResult'),
  bizType?: string(name='BizType'),
  currentPage?: int32(name='CurrentPage'),
  dataId?: string(name='DataId'),
  endDate?: string(name='EndDate'),
  imageId?: string(name='ImageId'),
  keywordId?: string(name='KeywordId'),
  label?: string(name='Label'),
  lang?: string(name='Lang'),
  libType?: string(name='LibType'),
  pageSize?: int32(name='PageSize'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
  sourceIp?: string(name='SourceIp'),
  startDate?: string(name='StartDate'),
  suggestion?: string(name='Suggestion'),
  taskId?: string(name='TaskId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeAuditContentResponseBody = {
  auditContentList?: [ 
    {
      audit?: int32(name='Audit'),
      auditIllegalReasons?: [ string ](name='AuditIllegalReasons'),
      auditResult?: string(name='AuditResult'),
      bizType?: string(name='BizType'),
      content?: string(name='Content'),
      dataId?: string(name='DataId'),
      frameResults?: [ 
        {
          label?: string(name='Label'),
          offset?: int32(name='Offset'),
          url?: string(name='Url'),
        }
      ](name='FrameResults'),
      id?: long(name='Id'),
      newUrl?: string(name='NewUrl'),
      requestTime?: string(name='RequestTime'),
      results?: [ 
        {
          label?: string(name='Label'),
          scene?: string(name='Scene'),
          suggestion?: string(name='Suggestion'),
        }
      ](name='Results'),
      scanFinishedTime?: string(name='ScanFinishedTime'),
      suggestion?: string(name='Suggestion'),
      taskId?: string(name='TaskId'),
      thumbnail?: string(name='Thumbnail'),
      url?: string(name='Url'),
    }
  ](name='AuditContentList'),
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeAuditContentResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAuditContentResponseBody(name='body'),
}

async function describeAuditContentWithOptions(request: DescribeAuditContentRequest, runtime: Util.RuntimeOptions): DescribeAuditContentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.auditResult)) {
    query['AuditResult'] = request.auditResult;
  }
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.dataId)) {
    query['DataId'] = request.dataId;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.imageId)) {
    query['ImageId'] = request.imageId;
  }
  if (!Util.isUnset(request.keywordId)) {
    query['KeywordId'] = request.keywordId;
  }
  if (!Util.isUnset(request.label)) {
    query['Label'] = request.label;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.libType)) {
    query['LibType'] = request.libType;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.suggestion)) {
    query['Suggestion'] = request.suggestion;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAuditContent',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAuditContent(request: DescribeAuditContentRequest): DescribeAuditContentResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditContentWithOptions(request, runtime);
}

model DescribeAuditContentItemRequest {
  currentPage?: int32(name='CurrentPage'),
  lang?: string(name='Lang'),
  pageSize?: int32(name='PageSize'),
  resourceType?: string(name='ResourceType'),
  sourceIp?: string(name='SourceIp'),
  taskId?: string(name='TaskId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeAuditContentItemResponseBody = {
  auditContentItemList?: [ 
    {
      audit?: int32(name='Audit'),
      auditIllegalReasons?: [ string ](name='AuditIllegalReasons'),
      auditResult?: string(name='AuditResult'),
      content?: string(name='Content'),
      endTime?: string(name='EndTime'),
      id?: long(name='Id'),
      parentTaskId?: string(name='ParentTaskId'),
      sn?: int32(name='Sn'),
      startTime?: string(name='StartTime'),
      suggestion?: string(name='Suggestion'),
    }
  ](name='AuditContentItemList'),
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeAuditContentItemResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAuditContentItemResponseBody(name='body'),
}

async function describeAuditContentItemWithOptions(request: DescribeAuditContentItemRequest, runtime: Util.RuntimeOptions): DescribeAuditContentItemResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAuditContentItem',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAuditContentItem(request: DescribeAuditContentItemRequest): DescribeAuditContentItemResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditContentItemWithOptions(request, runtime);
}

model DescribeAuditRangeResponseBody = {
  auditRange?: {
    block?: boolean(name='block'),
    pass?: boolean(name='pass'),
    review?: boolean(name='review'),
  }(name='AuditRange'),
  requestId?: string(name='RequestId'),
}

model DescribeAuditRangeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAuditRangeResponseBody(name='body'),
}

async function describeAuditRangeWithOptions(runtime: Util.RuntimeOptions): DescribeAuditRangeResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'DescribeAuditRange',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAuditRange(): DescribeAuditRangeResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditRangeWithOptions(runtime);
}

model DescribeAuditSettingRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeAuditSettingResponseBody = {
  auditRange?: {
    block?: boolean(name='block'),
    pass?: boolean(name='pass'),
    review?: boolean(name='review'),
  }(name='AuditRange'),
  callback?: string(name='Callback'),
  requestId?: string(name='RequestId'),
  seed?: string(name='Seed'),
}

model DescribeAuditSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeAuditSettingResponseBody(name='body'),
}

async function describeAuditSettingWithOptions(request: DescribeAuditSettingRequest, runtime: Util.RuntimeOptions): DescribeAuditSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeAuditSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeAuditSetting(request: DescribeAuditSettingRequest): DescribeAuditSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeAuditSettingWithOptions(request, runtime);
}

model DescribeBizTypeImageLibRequest {
  bizTypeName?: string(name='BizTypeName'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
}

model DescribeBizTypeImageLibResponseBody = {
  black?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Black'),
  requestId?: string(name='RequestId'),
  review?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Review'),
  white?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='White'),
}

model DescribeBizTypeImageLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBizTypeImageLibResponseBody(name='body'),
}

async function describeBizTypeImageLibWithOptions(request: DescribeBizTypeImageLibRequest, runtime: Util.RuntimeOptions): DescribeBizTypeImageLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypeName)) {
    query['BizTypeName'] = request.bizTypeName;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBizTypeImageLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeBizTypeImageLib(request: DescribeBizTypeImageLibRequest): DescribeBizTypeImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBizTypeImageLibWithOptions(request, runtime);
}

model DescribeBizTypeSettingRequest {
  bizTypeName?: string(name='BizTypeName'),
  resourceType?: string(name='ResourceType'),
}

model DescribeBizTypeSettingResponseBody = {
  ad?: {
    categories?: [ string ](name='Categories'),
  }(name='Ad'),
  antispam?: {
    categories?: [ string ](name='Categories'),
  }(name='Antispam'),
  live?: {
    categories?: [ string ](name='Categories'),
  }(name='Live'),
  porn?: {
    categories?: [ string ](name='Categories'),
  }(name='Porn'),
  requestId?: string(name='RequestId'),
  terrorism?: {
    categories?: [ string ](name='Categories'),
  }(name='Terrorism'),
}

model DescribeBizTypeSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBizTypeSettingResponseBody(name='body'),
}

async function describeBizTypeSettingWithOptions(request: DescribeBizTypeSettingRequest, runtime: Util.RuntimeOptions): DescribeBizTypeSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypeName)) {
    query['BizTypeName'] = request.bizTypeName;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBizTypeSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeBizTypeSetting(request: DescribeBizTypeSettingRequest): DescribeBizTypeSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBizTypeSettingWithOptions(request, runtime);
}

model DescribeBizTypeTextLibRequest {
  bizTypeName?: string(name='BizTypeName'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
}

model DescribeBizTypeTextLibResponseBody = {
  black?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Black'),
  ignore?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Ignore'),
  requestId?: string(name='RequestId'),
  review?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='Review'),
  white?: {
    all?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='All'),
    selected?: [ 
      {
        code?: string(name='Code'),
        name?: string(name='Name'),
      }
    ](name='Selected'),
  }(name='White'),
}

model DescribeBizTypeTextLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBizTypeTextLibResponseBody(name='body'),
}

async function describeBizTypeTextLibWithOptions(request: DescribeBizTypeTextLibRequest, runtime: Util.RuntimeOptions): DescribeBizTypeTextLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypeName)) {
    query['BizTypeName'] = request.bizTypeName;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBizTypeTextLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeBizTypeTextLib(request: DescribeBizTypeTextLibRequest): DescribeBizTypeTextLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBizTypeTextLibWithOptions(request, runtime);
}

model DescribeBizTypesRequest {
  importFlag?: boolean(name='ImportFlag'),
}

model DescribeBizTypesResponseBody = {
  bizTypeList?: [ string ](name='BizTypeList'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeBizTypesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeBizTypesResponseBody(name='body'),
}

async function describeBizTypesWithOptions(request: DescribeBizTypesRequest, runtime: Util.RuntimeOptions): DescribeBizTypesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.importFlag)) {
    query['ImportFlag'] = request.importFlag;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeBizTypes',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeBizTypes(request: DescribeBizTypesRequest): DescribeBizTypesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeBizTypesWithOptions(request, runtime);
}

model DescribeCloudMonitorServicesRequest {
  page?: string(name='Page'),
  pageSize?: string(name='PageSize'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeCloudMonitorServicesResponseBody = {
  items?: [ string ](name='Items'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeCloudMonitorServicesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeCloudMonitorServicesResponseBody(name='body'),
}

async function describeCloudMonitorServicesWithOptions(request: DescribeCloudMonitorServicesRequest, runtime: Util.RuntimeOptions): DescribeCloudMonitorServicesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.page)) {
    query['Page'] = request.page;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeCloudMonitorServices',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeCloudMonitorServices(request: DescribeCloudMonitorServicesRequest): DescribeCloudMonitorServicesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeCloudMonitorServicesWithOptions(request, runtime);
}

model DescribeCustomOcrTemplateRequest {
  ids?: string(name='Ids'),
}

model DescribeCustomOcrTemplateResponseBody = {
  ocrTemplateList?: [ 
    {
      id?: long(name='Id'),
      imgUrl?: string(name='ImgUrl'),
      name?: string(name='Name'),
      recognizeArea?: [ 
        {
          height?: int32(name='Height'),
          name?: string(name='Name'),
          width?: int32(name='Width'),
          x?: int32(name='X'),
          y?: int32(name='Y'),
        }
      ](name='RecognizeArea'),
      referArea?: [ 
        {
          height?: int32(name='Height'),
          name?: string(name='Name'),
          width?: int32(name='Width'),
          x?: int32(name='X'),
          y?: int32(name='Y'),
        }
      ](name='ReferArea'),
      status?: int32(name='Status'),
    }
  ](name='OcrTemplateList'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeCustomOcrTemplateResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeCustomOcrTemplateResponseBody(name='body'),
}

async function describeCustomOcrTemplateWithOptions(request: DescribeCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): DescribeCustomOcrTemplateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeCustomOcrTemplate',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeCustomOcrTemplate(request: DescribeCustomOcrTemplateRequest): DescribeCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeCustomOcrTemplateWithOptions(request, runtime);
}

model DescribeImageFromLibRequest {
  currentPage?: int32(name='CurrentPage'),
  endDate?: string(name='EndDate'),
  id?: long(name='Id'),
  imageLibId?: int32(name='ImageLibId'),
  modelId?: long(name='ModelId'),
  pageSize?: int32(name='PageSize'),
  sourceIp?: string(name='SourceIp'),
  startDate?: string(name='StartDate'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeImageFromLibResponseBody = {
  currentPage?: int32(name='CurrentPage'),
  imageFromLibList?: [ 
    {
      createTime?: string(name='CreateTime'),
      id?: long(name='Id'),
      image?: string(name='Image'),
      imageHitCount?: long(name='ImageHitCount'),
      thumbnail?: string(name='Thumbnail'),
      videoHitCount?: long(name='VideoHitCount'),
    }
  ](name='ImageFromLibList'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeImageFromLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeImageFromLibResponseBody(name='body'),
}

async function describeImageFromLibWithOptions(request: DescribeImageFromLibRequest, runtime: Util.RuntimeOptions): DescribeImageFromLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.imageLibId)) {
    query['ImageLibId'] = request.imageLibId;
  }
  if (!Util.isUnset(request.modelId)) {
    query['ModelId'] = request.modelId;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeImageFromLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeImageFromLib(request: DescribeImageFromLibRequest): DescribeImageFromLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeImageFromLibWithOptions(request, runtime);
}

model DescribeImageLibRequest {
  serviceModule?: string(name='ServiceModule', example='open_api'),
  sourceIp?: string(name='SourceIp', example='1.1.1.1'),
}

model DescribeImageLibResponseBody = {
  imageLibList?: [ 
    {
      bizTypes?: [ string ](name='BizTypes'),
      category?: string(name='Category', example='BLACK'),
      code?: string(name='Code', example='808003055'),
      enable?: string(name='Enable', example='true'),
      id?: int32(name='Id', example='1279'),
      imageCount?: int32(name='ImageCount', example='1912312312'),
      modifiedTime?: string(name='ModifiedTime', example='2018-03-19 10:45:44 +0800'),
      name?: string(name='Name'),
      scene?: string(name='Scene', example='PORN'),
      serviceModule?: string(name='ServiceModule', example='open_api'),
      source?: string(name='Source', example='MANUAL'),
    }
  ](name='ImageLibList'),
  requestId?: string(name='RequestId', example='6CF2815C-C8C7-4A01-B52E-FF6E24F53492'),
  totalCount?: int32(name='TotalCount', example='2'),
}

model DescribeImageLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeImageLibResponseBody(name='body'),
}

async function describeImageLibWithOptions(request: DescribeImageLibRequest, runtime: Util.RuntimeOptions): DescribeImageLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.serviceModule)) {
    query['ServiceModule'] = request.serviceModule;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeImageLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeImageLib(request: DescribeImageLibRequest): DescribeImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeImageLibWithOptions(request, runtime);
}

model DescribeImageUploadInfoRequest {
  sourceIp?: string(name='SourceIp'),
}

model DescribeImageUploadInfoResponseBody = {
  accessid?: string(name='Accessid'),
  expire?: int32(name='Expire'),
  folder?: string(name='Folder'),
  host?: string(name='Host'),
  policy?: string(name='Policy'),
  requestId?: string(name='RequestId'),
  signature?: string(name='Signature'),
}

model DescribeImageUploadInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeImageUploadInfoResponseBody(name='body'),
}

async function describeImageUploadInfoWithOptions(request: DescribeImageUploadInfoRequest, runtime: Util.RuntimeOptions): DescribeImageUploadInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeImageUploadInfo',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeImageUploadInfo(request: DescribeImageUploadInfoRequest): DescribeImageUploadInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeImageUploadInfoWithOptions(request, runtime);
}

model DescribeKeywordRequest {
  currentPage?: int32(name='CurrentPage'),
  keyword?: string(name='Keyword'),
  keywordLibId?: int32(name='KeywordLibId'),
  lang?: string(name='Lang'),
  pageSize?: int32(name='PageSize'),
  sourceIp?: string(name='SourceIp'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeKeywordResponseBody = {
  currentPage?: int32(name='CurrentPage'),
  keywordList?: [ 
    {
      createTime?: string(name='CreateTime'),
      hitCount?: int32(name='HitCount'),
      id?: int32(name='Id'),
      keyword?: string(name='Keyword'),
    }
  ](name='KeywordList'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeKeywordResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeKeywordResponseBody(name='body'),
}

async function describeKeywordWithOptions(request: DescribeKeywordRequest, runtime: Util.RuntimeOptions): DescribeKeywordResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.keyword)) {
    query['Keyword'] = request.keyword;
  }
  if (!Util.isUnset(request.keywordLibId)) {
    query['KeywordLibId'] = request.keywordLibId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeKeyword',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeKeyword(request: DescribeKeywordRequest): DescribeKeywordResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeKeywordWithOptions(request, runtime);
}

model DescribeKeywordLibRequest {
  lang?: string(name='Lang'),
  serviceModule?: string(name='ServiceModule'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeKeywordLibResponseBody = {
  keywordLibList?: [ 
    {
      bizTypes?: [ string ](name='BizTypes'),
      category?: string(name='Category'),
      code?: string(name='Code'),
      count?: int32(name='Count'),
      enable?: boolean(name='Enable'),
      id?: int32(name='Id'),
      language?: string(name='Language'),
      libType?: string(name='LibType'),
      matchMode?: string(name='MatchMode'),
      modifiedTime?: string(name='ModifiedTime'),
      name?: string(name='Name'),
      resourceType?: string(name='ResourceType'),
      serviceModule?: string(name='ServiceModule'),
      source?: string(name='Source'),
    }
  ](name='KeywordLibList'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeKeywordLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeKeywordLibResponseBody(name='body'),
}

async function describeKeywordLibWithOptions(request: DescribeKeywordLibRequest, runtime: Util.RuntimeOptions): DescribeKeywordLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.serviceModule)) {
    query['ServiceModule'] = request.serviceModule;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeKeywordLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeKeywordLib(request: DescribeKeywordLibRequest): DescribeKeywordLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeKeywordLibWithOptions(request, runtime);
}

model DescribeNotificationSettingRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeNotificationSettingResponseBody = {
  email?: string(name='Email'),
  phone?: string(name='Phone'),
  realtimeMessageList?: [ string ](name='RealtimeMessageList'),
  reminderModeList?: [ string ](name='ReminderModeList'),
  requestId?: string(name='RequestId'),
  scheduleMessageTime?: int32(name='ScheduleMessageTime'),
  scheduleMessageTimeZone?: int32(name='ScheduleMessageTimeZone'),
}

model DescribeNotificationSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeNotificationSettingResponseBody(name='body'),
}

async function describeNotificationSettingWithOptions(request: DescribeNotificationSettingRequest, runtime: Util.RuntimeOptions): DescribeNotificationSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeNotificationSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeNotificationSetting(request: DescribeNotificationSettingRequest): DescribeNotificationSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeNotificationSettingWithOptions(request, runtime);
}

model DescribeOpenApiRcpStatsRequest {
  bizType?: string(name='BizType'),
  endDate?: string(name='EndDate'),
  resourceType?: string(name='ResourceType'),
  startDate?: string(name='StartDate'),
}

model DescribeOpenApiRcpStatsResponseBody = {
  requestId?: string(name='RequestId'),
  statList?: [ 
    {
      blockCount?: int32(name='BlockCount'),
      date?: string(name='Date'),
      passCount?: int32(name='PassCount'),
      resourceType?: string(name='ResourceType'),
      reviewCount?: int32(name='ReviewCount'),
      totalCount?: int32(name='TotalCount'),
      totalDuration?: int32(name='TotalDuration'),
    }
  ](name='StatList'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeOpenApiRcpStatsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeOpenApiRcpStatsResponseBody(name='body'),
}

async function describeOpenApiRcpStatsWithOptions(request: DescribeOpenApiRcpStatsRequest, runtime: Util.RuntimeOptions): DescribeOpenApiRcpStatsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeOpenApiRcpStats',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeOpenApiRcpStats(request: DescribeOpenApiRcpStatsRequest): DescribeOpenApiRcpStatsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOpenApiRcpStatsWithOptions(request, runtime);
}

model DescribeOpenApiUsageRequest {
  endDate?: string(name='EndDate'),
  resourceType?: string(name='ResourceType'),
  sourceIp?: string(name='SourceIp'),
  startDate?: string(name='StartDate'),
}

model DescribeOpenApiUsageResponseBody = {
  openApiUsageList?: [ 
    {
      blockCount?: int32(name='BlockCount'),
      blockDuration?: int32(name='BlockDuration'),
      date?: string(name='Date'),
      innerTotalCount?: int32(name='InnerTotalCount'),
      outerTotalCount?: int32(name='OuterTotalCount'),
      passCount?: int32(name='PassCount'),
      passDuration?: int32(name='PassDuration'),
      resourceType?: string(name='ResourceType'),
      reviewCount?: int32(name='ReviewCount'),
      reviewDuration?: int32(name='ReviewDuration'),
      scene?: string(name='Scene'),
      totalCount?: int32(name='TotalCount'),
      totalDuration?: int32(name='TotalDuration'),
    }
  ](name='OpenApiUsageList'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeOpenApiUsageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeOpenApiUsageResponseBody(name='body'),
}

async function describeOpenApiUsageWithOptions(request: DescribeOpenApiUsageRequest, runtime: Util.RuntimeOptions): DescribeOpenApiUsageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeOpenApiUsage',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeOpenApiUsage(request: DescribeOpenApiUsageRequest): DescribeOpenApiUsageResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOpenApiUsageWithOptions(request, runtime);
}

model DescribeOssCallbackSettingResponseBody = {
  auditCallback?: boolean(name='AuditCallback'),
  callbackSeed?: string(name='CallbackSeed'),
  callbackUrl?: string(name='CallbackUrl'),
  requestId?: string(name='RequestId'),
  scanCallback?: boolean(name='ScanCallback'),
  scanCallbackSuggestions?: [ string ](name='ScanCallbackSuggestions'),
  serviceModules?: [ string ](name='ServiceModules'),
}

model DescribeOssCallbackSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeOssCallbackSettingResponseBody(name='body'),
}

async function describeOssCallbackSettingWithOptions(runtime: Util.RuntimeOptions): DescribeOssCallbackSettingResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'DescribeOssCallbackSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeOssCallbackSetting(): DescribeOssCallbackSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssCallbackSettingWithOptions(runtime);
}

model DescribeOssIncrementCheckSettingRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeOssIncrementCheckSettingResponseBody = {
  audioAntispamFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='AudioAntispamFreezeConfig'),
  audioAutoFreezeOpened?: boolean(name='AudioAutoFreezeOpened'),
  audioMaxSize?: int32(name='AudioMaxSize'),
  audioScanLimit?: long(name='AudioScanLimit'),
  audioSceneList?: [ string ](name='AudioSceneList'),
  autoFreezeType?: string(name='AutoFreezeType'),
  bizType?: string(name='BizType'),
  bizTypeTemplate?: {
    bizType?: string(name='BizType'),
    description?: string(name='Description'),
    imageConfig?: {
      ad?: {
        categories?: [ string ](name='Categories'),
      }(name='Ad'),
      live?: {
        categories?: [ string ](name='Categories'),
      }(name='Live'),
      porn?: {
        categories?: [ string ](name='Categories'),
      }(name='Porn'),
      terrorism?: {
        categories?: [ string ](name='Categories'),
      }(name='Terrorism'),
    }(name='ImageConfig'),
    includeChannel?: int32(name='IncludeChannel'),
    name?: string(name='Name'),
    videoConfig?: {
      ad?: {
        categories?: [ string ](name='Categories'),
      }(name='Ad'),
      live?: {
        categories?: [ string ](name='Categories'),
      }(name='Live'),
      porn?: {
        categories?: [ string ](name='Categories'),
      }(name='Porn'),
      terrorism?: {
        categories?: [ string ](name='Categories'),
      }(name='Terrorism'),
    }(name='VideoConfig'),
    voiceConfig?: {
      antispam?: {
        categories?: [ string ](name='Categories'),
      }(name='Antispam'),
    }(name='VoiceConfig'),
  }(name='BizTypeTemplate'),
  bucketConfigList?: [ 
    {
      bucket?: string(name='Bucket'),
      prefixes?: [ string ](name='Prefixes'),
      selected?: boolean(name='Selected'),
      type?: string(name='Type'),
    }
  ](name='BucketConfigList'),
  callbackId?: string(name='CallbackId'),
  callbackName?: string(name='CallbackName'),
  endTime?: string(name='EndTime'),
  imageAdFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='ImageAdFreezeConfig'),
  imageAutoFreeze?: {
    ad?: string(name='Ad'),
    enabled?: boolean(name='Enabled'),
    live?: string(name='Live'),
    porn?: string(name='Porn'),
    terrorism?: string(name='Terrorism'),
  }(name='ImageAutoFreeze'),
  imageAutoFreezeOpened?: boolean(name='ImageAutoFreezeOpened'),
  imageEnableLimit?: boolean(name='ImageEnableLimit'),
  imageLiveFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='ImageLiveFreezeConfig'),
  imagePornFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='ImagePornFreezeConfig'),
  imageScanLimit?: long(name='ImageScanLimit'),
  imageSceneList?: [ string ](name='ImageSceneList'),
  imageTerrorismFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='ImageTerrorismFreezeConfig'),
  requestId?: string(name='RequestId'),
  scanImageNoFileType?: boolean(name='ScanImageNoFileType'),
  startTime?: string(name='StartTime'),
  videoAdFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='VideoAdFreezeConfig'),
  videoAutoFreezeOpened?: boolean(name='VideoAutoFreezeOpened'),
  videoAutoFreezeSceneList?: [ string ](name='VideoAutoFreezeSceneList'),
  videoFrameInterval?: int32(name='VideoFrameInterval'),
  videoLiveFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='VideoLiveFreezeConfig'),
  videoMaxFrames?: int32(name='VideoMaxFrames'),
  videoMaxSize?: int32(name='VideoMaxSize'),
  videoPornFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='VideoPornFreezeConfig'),
  videoScanLimit?: long(name='VideoScanLimit'),
  videoSceneList?: [ string ](name='VideoSceneList'),
  videoTerrorismFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='VideoTerrorismFreezeConfig'),
  videoVoiceAntispamFreezeConfig?: {
    type?: string(name='Type'),
    value?: string(name='Value'),
  }(name='VideoVoiceAntispamFreezeConfig'),
}

model DescribeOssIncrementCheckSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeOssIncrementCheckSettingResponseBody(name='body'),
}

async function describeOssIncrementCheckSettingWithOptions(request: DescribeOssIncrementCheckSettingRequest, runtime: Util.RuntimeOptions): DescribeOssIncrementCheckSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeOssIncrementCheckSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeOssIncrementCheckSetting(request: DescribeOssIncrementCheckSettingRequest): DescribeOssIncrementCheckSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssIncrementCheckSettingWithOptions(request, runtime);
}

model DescribeOssIncrementOverviewRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeOssIncrementOverviewResponseBody = {
  adUnhandleCount?: int32(name='AdUnhandleCount'),
  audioCount?: int32(name='AudioCount'),
  imageCount?: int32(name='ImageCount'),
  liveUnhandleCount?: int32(name='LiveUnhandleCount'),
  pornUnhandleCount?: int32(name='PornUnhandleCount'),
  requestId?: string(name='RequestId'),
  terrorismUnhandleCount?: int32(name='TerrorismUnhandleCount'),
  videoCount?: int32(name='VideoCount'),
  videoFrameCount?: int32(name='VideoFrameCount'),
  voiceAntispamUnhandleCount?: int32(name='VoiceAntispamUnhandleCount'),
}

model DescribeOssIncrementOverviewResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeOssIncrementOverviewResponseBody(name='body'),
}

async function describeOssIncrementOverviewWithOptions(request: DescribeOssIncrementOverviewRequest, runtime: Util.RuntimeOptions): DescribeOssIncrementOverviewResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeOssIncrementOverview',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeOssIncrementOverview(request: DescribeOssIncrementOverviewRequest): DescribeOssIncrementOverviewResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssIncrementOverviewWithOptions(request, runtime);
}

model DescribeOssIncrementStatsRequest {
  endDate?: string(name='EndDate'),
  lang?: string(name='Lang'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
  sourceIp?: string(name='SourceIp'),
  startDate?: string(name='StartDate'),
}

model DescribeOssIncrementStatsResponseBody = {
  requestId?: string(name='RequestId'),
  statList?: [ 
    {
      blockCount?: int32(name='BlockCount'),
      date?: string(name='Date'),
      passCount?: int32(name='PassCount'),
      resourceType?: string(name='ResourceType'),
      reviewCount?: int32(name='ReviewCount'),
      scene?: string(name='Scene'),
      totalCount?: int32(name='TotalCount'),
    }
  ](name='StatList'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeOssIncrementStatsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeOssIncrementStatsResponseBody(name='body'),
}

async function describeOssIncrementStatsWithOptions(request: DescribeOssIncrementStatsRequest, runtime: Util.RuntimeOptions): DescribeOssIncrementStatsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeOssIncrementStats',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeOssIncrementStats(request: DescribeOssIncrementStatsRequest): DescribeOssIncrementStatsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssIncrementStatsWithOptions(request, runtime);
}

model DescribeOssResultItemsRequest {
  bucket?: string(name='Bucket'),
  currentPage?: int32(name='CurrentPage'),
  endDate?: string(name='EndDate'),
  lang?: string(name='Lang'),
  maxScore?: float(name='MaxScore'),
  minScore?: float(name='MinScore'),
  object?: string(name='Object'),
  pageSize?: int32(name='PageSize'),
  queryId?: string(name='QueryId'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
  sourceIp?: string(name='SourceIp'),
  startDate?: string(name='StartDate'),
  stock?: boolean(name='Stock'),
  stockTaskId?: long(name='StockTaskId'),
  suggestion?: string(name='Suggestion'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeOssResultItemsResponseBody = {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  queryId?: string(name='QueryId'),
  requestId?: string(name='RequestId'),
  scanResultList?: [ 
    {
      bucket?: string(name='Bucket'),
      content?: string(name='Content'),
      createTime?: string(name='CreateTime'),
      dataId?: string(name='DataId'),
      frameResults?: [ 
        {
          offset?: int32(name='Offset'),
          thumbnail?: string(name='Thumbnail'),
          url?: string(name='Url'),
        }
      ](name='FrameResults'),
      handleStatus?: int32(name='HandleStatus'),
      id?: long(name='Id'),
      newUrl?: string(name='NewUrl'),
      object?: string(name='Object'),
      requestTime?: string(name='RequestTime'),
      resourceStatus?: int32(name='ResourceStatus'),
      scanFinishedTime?: string(name='ScanFinishedTime'),
      score?: string(name='Score'),
      suggestion?: string(name='Suggestion'),
      taskId?: string(name='TaskId'),
      thumbnail?: string(name='Thumbnail'),
      voiceSegmentAntispamResults?: [ 
        {
          endTime?: int32(name='EndTime'),
          label?: string(name='Label'),
          startTime?: int32(name='StartTime'),
          text?: string(name='Text'),
        }
      ](name='VoiceSegmentAntispamResults'),
    }
  ](name='ScanResultList'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeOssResultItemsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeOssResultItemsResponseBody(name='body'),
}

async function describeOssResultItemsWithOptions(request: DescribeOssResultItemsRequest, runtime: Util.RuntimeOptions): DescribeOssResultItemsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bucket)) {
    query['Bucket'] = request.bucket;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.maxScore)) {
    query['MaxScore'] = request.maxScore;
  }
  if (!Util.isUnset(request.minScore)) {
    query['MinScore'] = request.minScore;
  }
  if (!Util.isUnset(request.object)) {
    query['Object'] = request.object;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.queryId)) {
    query['QueryId'] = request.queryId;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.stock)) {
    query['Stock'] = request.stock;
  }
  if (!Util.isUnset(request.stockTaskId)) {
    query['StockTaskId'] = request.stockTaskId;
  }
  if (!Util.isUnset(request.suggestion)) {
    query['Suggestion'] = request.suggestion;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeOssResultItems',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeOssResultItems(request: DescribeOssResultItemsRequest): DescribeOssResultItemsResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssResultItemsWithOptions(request, runtime);
}

model DescribeOssStockStatusRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
  stockTaskId?: long(name='StockTaskId'),
}

model DescribeOssStockStatusResponseBody = {
  audioAntispamCount?: int32(name='AudioAntispamCount'),
  audioTotalCount?: int32(name='AudioTotalCount'),
  bucketList?: [ 
    {
      bucket?: string(name='Bucket'),
      prefixes?: [ string ](name='Prefixes'),
      selected?: boolean(name='Selected'),
    }
  ](name='BucketList'),
  finishedTime?: string(name='FinishedTime'),
  imageAdCount?: int32(name='ImageAdCount'),
  imageLiveCount?: int32(name='ImageLiveCount'),
  imagePornCount?: int32(name='ImagePornCount'),
  imageTerrorismCount?: int32(name='ImageTerrorismCount'),
  imageTotalCount?: int32(name='ImageTotalCount'),
  requestId?: string(name='RequestId'),
  resouceTypeList?: [ string ](name='ResouceTypeList'),
  sceneList?: [ string ](name='SceneList'),
  stockStatus?: int32(name='StockStatus'),
  videoAdCount?: int32(name='VideoAdCount'),
  videoLiveCount?: int32(name='VideoLiveCount'),
  videoPornCount?: int32(name='VideoPornCount'),
  videoTerrorismCount?: int32(name='VideoTerrorismCount'),
  videoTotalCount?: int32(name='VideoTotalCount'),
  videoVoiceAntispamCount?: int32(name='VideoVoiceAntispamCount'),
}

model DescribeOssStockStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeOssStockStatusResponseBody(name='body'),
}

async function describeOssStockStatusWithOptions(request: DescribeOssStockStatusRequest, runtime: Util.RuntimeOptions): DescribeOssStockStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.stockTaskId)) {
    query['StockTaskId'] = request.stockTaskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeOssStockStatus',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeOssStockStatus(request: DescribeOssStockStatusRequest): DescribeOssStockStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeOssStockStatusWithOptions(request, runtime);
}

model DescribeSdkUrlRequest {
  debug?: boolean(name='Debug'),
  id?: long(name='Id'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeSdkUrlResponseBody = {
  requestId?: string(name='RequestId'),
  sdkUrl?: string(name='SdkUrl'),
}

model DescribeSdkUrlResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeSdkUrlResponseBody(name='body'),
}

async function describeSdkUrlWithOptions(request: DescribeSdkUrlRequest, runtime: Util.RuntimeOptions): DescribeSdkUrlResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.debug)) {
    query['Debug'] = request.debug;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeSdkUrl',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeSdkUrl(request: DescribeSdkUrlRequest): DescribeSdkUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeSdkUrlWithOptions(request, runtime);
}

model DescribeUpdatePackageResultRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
  taskId?: string(name='TaskId'),
}

model DescribeUpdatePackageResultResponseBody = {
  appInfo?: {
    debugPackageInfo?: {
      version?: string(name='Version'),
    }(name='DebugPackageInfo'),
    endDate?: string(name='EndDate'),
    icon?: string(name='Icon'),
    id?: long(name='Id'),
    name?: string(name='Name'),
    packageInfo?: {
      version?: string(name='Version'),
    }(name='PackageInfo'),
    packageName?: string(name='PackageName'),
    startDate?: string(name='StartDate'),
    type?: int32(name='Type'),
  }(name='AppInfo'),
  requestId?: string(name='RequestId'),
}

model DescribeUpdatePackageResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeUpdatePackageResultResponseBody(name='body'),
}

async function describeUpdatePackageResultWithOptions(request: DescribeUpdatePackageResultRequest, runtime: Util.RuntimeOptions): DescribeUpdatePackageResultResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeUpdatePackageResult',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeUpdatePackageResult(request: DescribeUpdatePackageResultRequest): DescribeUpdatePackageResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUpdatePackageResultWithOptions(request, runtime);
}

model DescribeUploadInfoRequest {
  biz?: string(name='Biz'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeUploadInfoResponseBody = {
  accessid?: string(name='Accessid'),
  expire?: int32(name='Expire'),
  folder?: string(name='Folder'),
  host?: string(name='Host'),
  policy?: string(name='Policy'),
  requestId?: string(name='RequestId'),
  signature?: string(name='Signature'),
}

model DescribeUploadInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeUploadInfoResponseBody(name='body'),
}

async function describeUploadInfoWithOptions(request: DescribeUploadInfoRequest, runtime: Util.RuntimeOptions): DescribeUploadInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.biz)) {
    query['Biz'] = request.biz;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeUploadInfo',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeUploadInfo(request: DescribeUploadInfoRequest): DescribeUploadInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUploadInfoWithOptions(request, runtime);
}

model DescribeUsageBillRequest {
  currentPage?: int32(name='CurrentPage'),
  day?: string(name='Day'),
  pageSize?: int32(name='PageSize'),
  totalCount?: int32(name='TotalCount'),
  type?: string(name='Type'),
}

model DescribeUsageBillResponseBody = {
  billList?: [ 
    {
      bizType?: string(name='BizType'),
      confirmCount?: long(name='ConfirmCount'),
      day?: string(name='Day'),
      freeCount?: long(name='FreeCount'),
      region?: string(name='Region'),
      reviewCount?: long(name='ReviewCount'),
      scene?: string(name='Scene'),
      subUid?: string(name='SubUid'),
      totalCount?: long(name='TotalCount'),
    }
  ](name='BillList'),
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeUsageBillResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeUsageBillResponseBody(name='body'),
}

async function describeUsageBillWithOptions(request: DescribeUsageBillRequest, runtime: Util.RuntimeOptions): DescribeUsageBillResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.day)) {
    query['Day'] = request.day;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  if (!Util.isUnset(request.type)) {
    query['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeUsageBill',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeUsageBill(request: DescribeUsageBillRequest): DescribeUsageBillResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUsageBillWithOptions(request, runtime);
}

model DescribeUserBizTypesRequest {
  customized?: boolean(name='Customized'),
}

model DescribeUserBizTypesResponseBody = {
  bizTypeList?: [ 
    {
      bizType?: string(name='BizType'),
      citeTemplate?: boolean(name='CiteTemplate'),
      description?: string(name='Description'),
      gray?: boolean(name='Gray'),
      industryInfo?: string(name='IndustryInfo'),
      source?: string(name='Source'),
      sourceBizType?: string(name='SourceBizType'),
    }
  ](name='BizTypeList'),
  bizTypeListImport?: [ 
    {
      bizType?: string(name='BizType'),
      citeTemplate?: boolean(name='CiteTemplate'),
      description?: string(name='Description'),
      gray?: boolean(name='Gray'),
      industryInfo?: string(name='IndustryInfo'),
      source?: string(name='Source'),
      sourceBizType?: string(name='SourceBizType'),
    }
  ](name='BizTypeListImport'),
  requestId?: string(name='RequestId'),
}

model DescribeUserBizTypesResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeUserBizTypesResponseBody(name='body'),
}

async function describeUserBizTypesWithOptions(request: DescribeUserBizTypesRequest, runtime: Util.RuntimeOptions): DescribeUserBizTypesResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.customized)) {
    query['Customized'] = request.customized;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeUserBizTypes',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeUserBizTypes(request: DescribeUserBizTypesRequest): DescribeUserBizTypesResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUserBizTypesWithOptions(request, runtime);
}

model DescribeUserStatusRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeUserStatusResponseBody = {
  agreeChannel?: int32(name='AgreeChannel'),
  buyed?: boolean(name='Buyed'),
  inDept?: boolean(name='InDept'),
  openApiBeginTime?: string(name='OpenApiBeginTime'),
  openApiUsed?: boolean(name='OpenApiUsed'),
  ossCheckStatus?: string(name='OssCheckStatus'),
  ossVideoSizeLimit?: int32(name='OssVideoSizeLimit'),
  requestId?: string(name='RequestId'),
  uid?: string(name='Uid'),
}

model DescribeUserStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeUserStatusResponseBody(name='body'),
}

async function describeUserStatusWithOptions(request: DescribeUserStatusRequest, runtime: Util.RuntimeOptions): DescribeUserStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeUserStatus',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeUserStatus(request: DescribeUserStatusRequest): DescribeUserStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeUserStatusWithOptions(request, runtime);
}

model DescribeViewContentRequest {
  auditResult?: string(name='AuditResult'),
  bizType?: string(name='BizType'),
  currentPage?: int32(name='CurrentPage'),
  dataId?: string(name='DataId'),
  endDate?: string(name='EndDate'),
  imageId?: string(name='ImageId'),
  keyword?: string(name='Keyword'),
  keywordId?: string(name='KeywordId'),
  label?: string(name='Label'),
  libType?: string(name='LibType'),
  pageSize?: int32(name='PageSize'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
  startDate?: string(name='StartDate'),
  suggestion?: string(name='Suggestion'),
  taskId?: string(name='TaskId'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeViewContentResponseBody = {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
  viewContentList?: [ 
    {
      bizType?: string(name='BizType'),
      content?: string(name='Content'),
      dataId?: string(name='DataId'),
      faceResults?: [ 
        {
          age?: {
            rate?: float(name='Rate'),
            value?: int32(name='Value'),
          }(name='Age'),
          bang?: {
            rate?: float(name='Rate'),
            value?: string(name='Value'),
          }(name='Bang'),
          bualified?: boolean(name='Bualified'),
          gender?: {
            rate?: float(name='Rate'),
            value?: string(name='Value'),
          }(name='Gender'),
          glasses?: {
            rate?: float(name='Rate'),
            value?: string(name='Value'),
          }(name='Glasses'),
          hairstyle?: {
            rate?: float(name='Rate'),
            value?: string(name='Value'),
          }(name='Hairstyle'),
          hat?: {
            rate?: float(name='Rate'),
            value?: string(name='Value'),
          }(name='Hat'),
          image?: {
            height?: int32(name='Height'),
            width?: int32(name='Width'),
          }(name='Image'),
          location?: {
            h?: int32(name='H'),
            w?: int32(name='W'),
            x?: int32(name='X'),
            y?: int32(name='Y'),
          }(name='Location'),
          mustache?: {
            rate?: float(name='Rate'),
            value?: string(name='Value'),
          }(name='Mustache'),
          quality?: {
            blur?: float(name='Blur'),
            pitch?: float(name='Pitch'),
            roll?: float(name='Roll'),
            yaw?: float(name='Yaw'),
          }(name='Quality'),
          respirator?: {
            rate?: float(name='Rate'),
            value?: string(name='Value'),
          }(name='Respirator'),
          smile?: {
            rate?: float(name='Rate'),
            value?: float(name='Value'),
          }(name='Smile'),
        }
      ](name='FaceResults'),
      frameResults?: [ 
        {
          label?: string(name='Label'),
          offset?: int32(name='Offset'),
          url?: string(name='Url'),
        }
      ](name='FrameResults'),
      id?: long(name='Id'),
      newUrl?: string(name='NewUrl'),
      requestTime?: string(name='RequestTime'),
      results?: [ 
        {
          label?: string(name='Label'),
          scene?: string(name='Scene'),
          suggestion?: string(name='Suggestion'),
        }
      ](name='Results'),
      scanFinishedTime?: string(name='ScanFinishedTime'),
      scanResult?: string(name='ScanResult'),
      suggestion?: string(name='Suggestion'),
      taskId?: string(name='TaskId'),
      thumbnail?: string(name='Thumbnail'),
      url?: string(name='Url'),
    }
  ](name='ViewContentList'),
}

model DescribeViewContentResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeViewContentResponseBody(name='body'),
}

async function describeViewContentWithOptions(request: DescribeViewContentRequest, runtime: Util.RuntimeOptions): DescribeViewContentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.auditResult)) {
    query['AuditResult'] = request.auditResult;
  }
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.dataId)) {
    query['DataId'] = request.dataId;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.imageId)) {
    query['ImageId'] = request.imageId;
  }
  if (!Util.isUnset(request.keyword)) {
    query['Keyword'] = request.keyword;
  }
  if (!Util.isUnset(request.keywordId)) {
    query['KeywordId'] = request.keywordId;
  }
  if (!Util.isUnset(request.label)) {
    query['Label'] = request.label;
  }
  if (!Util.isUnset(request.libType)) {
    query['LibType'] = request.libType;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.suggestion)) {
    query['Suggestion'] = request.suggestion;
  }
  if (!Util.isUnset(request.taskId)) {
    query['TaskId'] = request.taskId;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeViewContent',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeViewContent(request: DescribeViewContentRequest): DescribeViewContentResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeViewContentWithOptions(request, runtime);
}

model DescribeWebsiteIndexPageBaselineRequest {
  instanceId?: string(name='InstanceId'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeWebsiteIndexPageBaselineResponseBody = {
  baseLineStatus?: string(name='BaseLineStatus'),
  createTime?: string(name='CreateTime'),
  requestId?: string(name='RequestId'),
  snapshot?: string(name='Snapshot'),
}

model DescribeWebsiteIndexPageBaselineResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeWebsiteIndexPageBaselineResponseBody(name='body'),
}

async function describeWebsiteIndexPageBaselineWithOptions(request: DescribeWebsiteIndexPageBaselineRequest, runtime: Util.RuntimeOptions): DescribeWebsiteIndexPageBaselineResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeWebsiteIndexPageBaseline',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeWebsiteIndexPageBaseline(request: DescribeWebsiteIndexPageBaselineRequest): DescribeWebsiteIndexPageBaselineResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteIndexPageBaselineWithOptions(request, runtime);
}

model DescribeWebsiteInstanceRequest {
  currentPage?: int32(name='CurrentPage'),
  instanceId?: string(name='InstanceId'),
  lang?: string(name='Lang'),
  pageSize?: int32(name='PageSize'),
  sourceIp?: string(name='SourceIp'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeWebsiteInstanceResponseBody = {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
  websiteInstanceList?: [ 
    {
      buyTime?: string(name='BuyTime'),
      domain?: string(name='Domain'),
      expiredTime?: string(name='ExpiredTime'),
      indexPage?: string(name='IndexPage'),
      indexPageScanInterval?: int32(name='IndexPageScanInterval'),
      instanceId?: string(name='InstanceId'),
      protocol?: string(name='Protocol'),
      status?: string(name='Status'),
      websiteScanInterval?: int32(name='WebsiteScanInterval'),
    }
  ](name='WebsiteInstanceList'),
}

model DescribeWebsiteInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeWebsiteInstanceResponseBody(name='body'),
}

async function describeWebsiteInstanceWithOptions(request: DescribeWebsiteInstanceRequest, runtime: Util.RuntimeOptions): DescribeWebsiteInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeWebsiteInstance',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeWebsiteInstance(request: DescribeWebsiteInstanceRequest): DescribeWebsiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteInstanceWithOptions(request, runtime);
}

model DescribeWebsiteInstanceIdRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeWebsiteInstanceIdResponseBody = {
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
  websiteInstanceIdList?: [ string ](name='WebsiteInstanceIdList'),
}

model DescribeWebsiteInstanceIdResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeWebsiteInstanceIdResponseBody(name='body'),
}

async function describeWebsiteInstanceIdWithOptions(request: DescribeWebsiteInstanceIdRequest, runtime: Util.RuntimeOptions): DescribeWebsiteInstanceIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeWebsiteInstanceId',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeWebsiteInstanceId(request: DescribeWebsiteInstanceIdRequest): DescribeWebsiteInstanceIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteInstanceIdWithOptions(request, runtime);
}

model DescribeWebsiteInstanceKeyUrlRequest {
  instanceId?: string(name='InstanceId'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeWebsiteInstanceKeyUrlResponseBody = {
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
  websiteInstanceKeyUrlList?: [ string ](name='WebsiteInstanceKeyUrlList'),
}

model DescribeWebsiteInstanceKeyUrlResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeWebsiteInstanceKeyUrlResponseBody(name='body'),
}

async function describeWebsiteInstanceKeyUrlWithOptions(request: DescribeWebsiteInstanceKeyUrlRequest, runtime: Util.RuntimeOptions): DescribeWebsiteInstanceKeyUrlResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeWebsiteInstanceKeyUrl',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeWebsiteInstanceKeyUrl(request: DescribeWebsiteInstanceKeyUrlRequest): DescribeWebsiteInstanceKeyUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteInstanceKeyUrlWithOptions(request, runtime);
}

model DescribeWebsiteScanResultRequest {
  currentPage?: int32(name='CurrentPage'),
  domain?: string(name='Domain'),
  handleStatus?: string(name='HandleStatus'),
  label?: string(name='Label'),
  lang?: string(name='Lang'),
  pageSize?: int32(name='PageSize'),
  siteUrl?: string(name='SiteUrl'),
  sourceIp?: string(name='SourceIp'),
  subServiceModule?: string(name='SubServiceModule'),
  totalCount?: int32(name='TotalCount'),
}

model DescribeWebsiteScanResultResponseBody = {
  currentPage?: int32(name='CurrentPage'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
  websiteScanResultList?: [ 
    {
      domain?: string(name='Domain'),
      handleStatus?: int32(name='HandleStatus'),
      id?: int32(name='Id'),
      imageRiskCount?: int32(name='ImageRiskCount'),
      instanceId?: string(name='InstanceId'),
      labels?: [ string ](name='Labels'),
      scanTime?: string(name='ScanTime'),
      sourceRiskCount?: int32(name='SourceRiskCount'),
      taskId?: string(name='TaskId'),
      textRiskCount?: int32(name='TextRiskCount'),
      url?: string(name='Url'),
    }
  ](name='WebsiteScanResultList'),
}

model DescribeWebsiteScanResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeWebsiteScanResultResponseBody(name='body'),
}

async function describeWebsiteScanResultWithOptions(request: DescribeWebsiteScanResultRequest, runtime: Util.RuntimeOptions): DescribeWebsiteScanResultResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.domain)) {
    query['Domain'] = request.domain;
  }
  if (!Util.isUnset(request.handleStatus)) {
    query['HandleStatus'] = request.handleStatus;
  }
  if (!Util.isUnset(request.label)) {
    query['Label'] = request.label;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.siteUrl)) {
    query['SiteUrl'] = request.siteUrl;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.subServiceModule)) {
    query['SubServiceModule'] = request.subServiceModule;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeWebsiteScanResult',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeWebsiteScanResult(request: DescribeWebsiteScanResultRequest): DescribeWebsiteScanResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteScanResultWithOptions(request, runtime);
}

model DescribeWebsiteScanResultDetailRequest {
  id?: int32(name='Id'),
  lang?: string(name='Lang'),
  resourceType?: string(name='ResourceType'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeWebsiteScanResultDetailResponseBody = {
  baseline?: string(name='Baseline'),
  content?: string(name='Content'),
  hitKeywords?: [ string ](name='HitKeywords'),
  imageScanResults?: [ 
    {
      labels?: [ string ](name='Labels'),
      url?: string(name='Url'),
    }
  ](name='ImageScanResults'),
  requestId?: string(name='RequestId'),
  resourceType?: string(name='ResourceType'),
  tamperedSource?: string(name='TamperedSource'),
}

model DescribeWebsiteScanResultDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeWebsiteScanResultDetailResponseBody(name='body'),
}

async function describeWebsiteScanResultDetailWithOptions(request: DescribeWebsiteScanResultDetailRequest, runtime: Util.RuntimeOptions): DescribeWebsiteScanResultDetailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeWebsiteScanResultDetail',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeWebsiteScanResultDetail(request: DescribeWebsiteScanResultDetailRequest): DescribeWebsiteScanResultDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteScanResultDetailWithOptions(request, runtime);
}

model DescribeWebsiteStatRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeWebsiteStatResponseBody = {
  requestId?: string(name='RequestId'),
  totalCount?: int32(name='TotalCount'),
  websiteStatList?: [ 
    {
      instanceCount?: int32(name='InstanceCount'),
      riskCount?: int32(name='RiskCount'),
      scanCount?: int32(name='ScanCount'),
      subServiceModule?: string(name='SubServiceModule'),
    }
  ](name='WebsiteStatList'),
}

model DescribeWebsiteStatResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeWebsiteStatResponseBody(name='body'),
}

async function describeWebsiteStatWithOptions(request: DescribeWebsiteStatRequest, runtime: Util.RuntimeOptions): DescribeWebsiteStatResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeWebsiteStat',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeWebsiteStat(request: DescribeWebsiteStatRequest): DescribeWebsiteStatResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteStatWithOptions(request, runtime);
}

model DescribeWebsiteVerifyInfoRequest {
  instanceId?: string(name='InstanceId'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model DescribeWebsiteVerifyInfoResponseBody = {
  cname?: string(name='Cname'),
  domain?: string(name='Domain'),
  hostFile?: string(name='HostFile'),
  indexPage?: string(name='IndexPage'),
  protocol?: string(name='Protocol'),
  requestId?: string(name='RequestId'),
  verifyMethod?: string(name='VerifyMethod'),
}

model DescribeWebsiteVerifyInfoResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: DescribeWebsiteVerifyInfoResponseBody(name='body'),
}

async function describeWebsiteVerifyInfoWithOptions(request: DescribeWebsiteVerifyInfoRequest, runtime: Util.RuntimeOptions): DescribeWebsiteVerifyInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DescribeWebsiteVerifyInfo',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function describeWebsiteVerifyInfo(request: DescribeWebsiteVerifyInfoRequest): DescribeWebsiteVerifyInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return describeWebsiteVerifyInfoWithOptions(request, runtime);
}

model ExportKeywordsRequest {
  keywordLibId?: long(name='KeywordLibId'),
}

model ExportKeywordsResponseBody = {
  downloadUrl?: string(name='DownloadUrl'),
  requestId?: string(name='RequestId'),
}

model ExportKeywordsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ExportKeywordsResponseBody(name='body'),
}

async function exportKeywordsWithOptions(request: ExportKeywordsRequest, runtime: Util.RuntimeOptions): ExportKeywordsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.keywordLibId)) {
    query['KeywordLibId'] = request.keywordLibId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ExportKeywords',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function exportKeywords(request: ExportKeywordsRequest): ExportKeywordsResponse {
  var runtime = new Util.RuntimeOptions{};
  return exportKeywordsWithOptions(request, runtime);
}

model ExportOpenApiRcpStatsRequest {
  bizType?: string(name='BizType'),
  endDate?: string(name='EndDate'),
  resourceType?: string(name='ResourceType'),
  startDate?: string(name='StartDate'),
}

model ExportOpenApiRcpStatsResponseBody = {
  downloadUrl?: string(name='DownloadUrl'),
  requestId?: string(name='RequestId'),
}

model ExportOpenApiRcpStatsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ExportOpenApiRcpStatsResponseBody(name='body'),
}

async function exportOpenApiRcpStatsWithOptions(request: ExportOpenApiRcpStatsRequest, runtime: Util.RuntimeOptions): ExportOpenApiRcpStatsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ExportOpenApiRcpStats',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function exportOpenApiRcpStats(request: ExportOpenApiRcpStatsRequest): ExportOpenApiRcpStatsResponse {
  var runtime = new Util.RuntimeOptions{};
  return exportOpenApiRcpStatsWithOptions(request, runtime);
}

model ExportOssResultRequest {
  bucket?: string(name='Bucket'),
  currentPage?: int32(name='CurrentPage'),
  endDate?: string(name='EndDate'),
  lang?: string(name='Lang'),
  maxScore?: float(name='MaxScore'),
  minScore?: float(name='MinScore'),
  pageSize?: int32(name='PageSize'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
  sourceIp?: string(name='SourceIp'),
  startDate?: string(name='StartDate'),
  stock?: boolean(name='Stock'),
  stockTaskId?: long(name='StockTaskId'),
  suggestion?: string(name='Suggestion'),
  totalCount?: int32(name='TotalCount'),
}

model ExportOssResultResponseBody = {
  fileUrl?: string(name='FileUrl'),
  requestId?: string(name='RequestId'),
}

model ExportOssResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ExportOssResultResponseBody(name='body'),
}

async function exportOssResultWithOptions(request: ExportOssResultRequest, runtime: Util.RuntimeOptions): ExportOssResultResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bucket)) {
    query['Bucket'] = request.bucket;
  }
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.maxScore)) {
    query['MaxScore'] = request.maxScore;
  }
  if (!Util.isUnset(request.minScore)) {
    query['MinScore'] = request.minScore;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.stock)) {
    query['Stock'] = request.stock;
  }
  if (!Util.isUnset(request.stockTaskId)) {
    query['StockTaskId'] = request.stockTaskId;
  }
  if (!Util.isUnset(request.suggestion)) {
    query['Suggestion'] = request.suggestion;
  }
  if (!Util.isUnset(request.totalCount)) {
    query['TotalCount'] = request.totalCount;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ExportOssResult',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function exportOssResult(request: ExportOssResultRequest): ExportOssResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return exportOssResultWithOptions(request, runtime);
}

model GetAuditItemDetailRequest {
  taskId?: string(name='TaskId'),
  type?: string(name='Type'),
}

model GetAuditItemDetailResponseBody = {
  apiResult?: string(name='ApiResult'),
  apiRiskType?: string(name='ApiRiskType'),
  apiTs?: string(name='ApiTs'),
  newUrl?: string(name='NewUrl'),
  requestId?: string(name='RequestId'),
}

model GetAuditItemDetailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAuditItemDetailResponseBody(name='body'),
}

async function getAuditItemDetailWithOptions(request: GetAuditItemDetailRequest, runtime: Util.RuntimeOptions): GetAuditItemDetailResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAuditItemDetail',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAuditItemDetail(request: GetAuditItemDetailRequest): GetAuditItemDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAuditItemDetailWithOptions(request, runtime);
}

model GetAuditItemListRequest {
  bizType?: string(name='BizType'),
  currentPage?: long(name='CurrentPage'),
  customResult?: string(name='CustomResult'),
  customRiskType?: string(name='CustomRiskType'),
  dataId?: string(name='DataId'),
  endDate?: string(name='EndDate'),
  pageSize?: long(name='PageSize'),
  rcpResult?: string(name='RcpResult'),
  rcpRiskType?: string(name='RcpRiskType'),
  startDate?: string(name='StartDate'),
  taskId?: string(name='TaskId'),
  type?: string(name='Type'),
}

model GetAuditItemListResponseBody = {
  currentPage?: long(name='CurrentPage'),
  items?: [ 
    {
      bizType?: string(name='BizType'),
      content?: string(name='Content'),
      create?: string(name='Create'),
      customResult?: string(name='CustomResult'),
      customRiskType?: string(name='CustomRiskType'),
      customTs?: string(name='CustomTs'),
      dataId?: string(name='DataId'),
      id?: long(name='Id'),
      operator?: string(name='Operator'),
      rcpResult?: string(name='RcpResult'),
      rcpRiskType?: string(name='RcpRiskType'),
      rcpTs?: string(name='RcpTs'),
      subUid?: string(name='SubUid'),
      taskId?: string(name='TaskId'),
      thumbnail?: string(name='Thumbnail'),
      type?: string(name='Type'),
      uid?: string(name='Uid'),
      url?: string(name='Url'),
    }
  ](name='Items'),
  pageSize?: long(name='PageSize'),
  requestId?: string(name='RequestId'),
  totalCount?: long(name='TotalCount'),
}

model GetAuditItemListResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAuditItemListResponseBody(name='body'),
}

async function getAuditItemListWithOptions(request: GetAuditItemListRequest, runtime: Util.RuntimeOptions): GetAuditItemListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAuditItemList',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAuditItemList(request: GetAuditItemListRequest): GetAuditItemListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAuditItemListWithOptions(request, runtime);
}

model GetAuditUserConfResponseBody = {
  customAudit?: boolean(name='CustomAudit'),
  rcpLabels?: map[string][ string ](name='RcpLabels'),
  requestId?: string(name='RequestId'),
  userLabels?: map[string][ string ](name='UserLabels'),
}

model GetAuditUserConfResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: GetAuditUserConfResponseBody(name='body'),
}

async function getAuditUserConfWithOptions(runtime: Util.RuntimeOptions): GetAuditUserConfResponse {
  var req = new OpenApi.OpenApiRequest{};
  var params = new OpenApi.Params{
    action = 'GetAuditUserConf',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAuditUserConf(): GetAuditUserConfResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAuditUserConfWithOptions(runtime);
}

model ImportKeywordsRequest {
  keywordLibId?: int32(name='KeywordLibId'),
  keywordsObject?: string(name='KeywordsObject'),
}

model ImportKeywordsResponseBody = {
  invalidKeywordList?: [ string ](name='InvalidKeywordList'),
  requestId?: string(name='RequestId'),
  successCount?: int32(name='SuccessCount'),
  validKeywordList?: [ string ](name='validKeywordList'),
}

model ImportKeywordsResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: ImportKeywordsResponseBody(name='body'),
}

async function importKeywordsWithOptions(request: ImportKeywordsRequest, runtime: Util.RuntimeOptions): ImportKeywordsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.keywordLibId)) {
    query['KeywordLibId'] = request.keywordLibId;
  }
  if (!Util.isUnset(request.keywordsObject)) {
    query['KeywordsObject'] = request.keywordsObject;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ImportKeywords',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function importKeywords(request: ImportKeywordsRequest): ImportKeywordsResponse {
  var runtime = new Util.RuntimeOptions{};
  return importKeywordsWithOptions(request, runtime);
}

model MarkAuditContentRequest {
  auditIllegalReasons?: string(name='AuditIllegalReasons'),
  auditResult?: string(name='AuditResult'),
  bizTypes?: string(name='BizTypes'),
  ids?: string(name='Ids'),
  sourceIp?: string(name='SourceIp'),
}

model MarkAuditContentResponseBody = {
  requestId?: string(name='RequestId'),
}

model MarkAuditContentResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: MarkAuditContentResponseBody(name='body'),
}

async function markAuditContentWithOptions(request: MarkAuditContentRequest, runtime: Util.RuntimeOptions): MarkAuditContentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.auditIllegalReasons)) {
    query['AuditIllegalReasons'] = request.auditIllegalReasons;
  }
  if (!Util.isUnset(request.auditResult)) {
    query['AuditResult'] = request.auditResult;
  }
  if (!Util.isUnset(request.bizTypes)) {
    query['BizTypes'] = request.bizTypes;
  }
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MarkAuditContent',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function markAuditContent(request: MarkAuditContentRequest): MarkAuditContentResponse {
  var runtime = new Util.RuntimeOptions{};
  return markAuditContentWithOptions(request, runtime);
}

model MarkAuditContentItemRequest {
  auditIllegalReasons?: string(name='AuditIllegalReasons'),
  auditResult?: string(name='AuditResult'),
  bizTypes?: string(name='BizTypes'),
  ids?: string(name='Ids'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model MarkAuditContentItemResponseBody = {
  requestId?: string(name='RequestId'),
}

model MarkAuditContentItemResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: MarkAuditContentItemResponseBody(name='body'),
}

async function markAuditContentItemWithOptions(request: MarkAuditContentItemRequest, runtime: Util.RuntimeOptions): MarkAuditContentItemResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.auditIllegalReasons)) {
    query['AuditIllegalReasons'] = request.auditIllegalReasons;
  }
  if (!Util.isUnset(request.auditResult)) {
    query['AuditResult'] = request.auditResult;
  }
  if (!Util.isUnset(request.bizTypes)) {
    query['BizTypes'] = request.bizTypes;
  }
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MarkAuditContentItem',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function markAuditContentItem(request: MarkAuditContentItemRequest): MarkAuditContentItemResponse {
  var runtime = new Util.RuntimeOptions{};
  return markAuditContentItemWithOptions(request, runtime);
}

model MarkOssResultRequest {
  ids?: string(name='Ids'),
  lang?: string(name='Lang'),
  operation?: string(name='Operation'),
  resourceType?: string(name='ResourceType'),
  scene?: string(name='Scene'),
  sourceIp?: string(name='SourceIp'),
  stock?: boolean(name='Stock'),
}

model MarkOssResultResponseBody = {
  requestId?: string(name='RequestId'),
}

model MarkOssResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: MarkOssResultResponseBody(name='body'),
}

async function markOssResultWithOptions(request: MarkOssResultRequest, runtime: Util.RuntimeOptions): MarkOssResultResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.operation)) {
    query['Operation'] = request.operation;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.stock)) {
    query['Stock'] = request.stock;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MarkOssResult',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function markOssResult(request: MarkOssResultRequest): MarkOssResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return markOssResultWithOptions(request, runtime);
}

model MarkWebsiteScanResultRequest {
  ids?: string(name='Ids'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model MarkWebsiteScanResultResponseBody = {
  requestId?: string(name='RequestId'),
}

model MarkWebsiteScanResultResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: MarkWebsiteScanResultResponseBody(name='body'),
}

async function markWebsiteScanResultWithOptions(request: MarkWebsiteScanResultRequest, runtime: Util.RuntimeOptions): MarkWebsiteScanResultResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ids)) {
    query['Ids'] = request.ids;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'MarkWebsiteScanResult',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function markWebsiteScanResult(request: MarkWebsiteScanResultRequest): MarkWebsiteScanResultResponse {
  var runtime = new Util.RuntimeOptions{};
  return markWebsiteScanResultWithOptions(request, runtime);
}

model RefundCdiBagRequest {
  instanceId?: string(name='InstanceId'),
  resourceOwnerId?: string(name='ResourceOwnerId'),
}

model RefundCdiBagResponseBody = {
  requestId?: string(name='RequestId'),
}

model RefundCdiBagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RefundCdiBagResponseBody(name='body'),
}

async function refundCdiBagWithOptions(request: RefundCdiBagRequest, runtime: Util.RuntimeOptions): RefundCdiBagResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RefundCdiBag',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function refundCdiBag(request: RefundCdiBagRequest): RefundCdiBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return refundCdiBagWithOptions(request, runtime);
}

model RefundCdiBaseBagRequest {
  instanceId?: string(name='InstanceId'),
  resourceOwnerId?: string(name='ResourceOwnerId'),
}

model RefundCdiBaseBagResponseBody = {
  requestId?: string(name='RequestId'),
}

model RefundCdiBaseBagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RefundCdiBaseBagResponseBody(name='body'),
}

async function refundCdiBaseBagWithOptions(request: RefundCdiBaseBagRequest, runtime: Util.RuntimeOptions): RefundCdiBaseBagResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RefundCdiBaseBag',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function refundCdiBaseBag(request: RefundCdiBaseBagRequest): RefundCdiBaseBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return refundCdiBaseBagWithOptions(request, runtime);
}

model RefundWebSiteInstanceRequest {
  instanceId?: string(name='InstanceId'),
  resourceOwnerId?: string(name='ResourceOwnerId'),
}

model RefundWebSiteInstanceResponseBody = {
  requestId?: string(name='RequestId'),
}

model RefundWebSiteInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RefundWebSiteInstanceResponseBody(name='body'),
}

async function refundWebSiteInstanceWithOptions(request: RefundWebSiteInstanceRequest, runtime: Util.RuntimeOptions): RefundWebSiteInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.resourceOwnerId)) {
    query['ResourceOwnerId'] = request.resourceOwnerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RefundWebSiteInstance',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function refundWebSiteInstance(request: RefundWebSiteInstanceRequest): RefundWebSiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return refundWebSiteInstanceWithOptions(request, runtime);
}

model RenewWebSiteInstanceRequest {
  clientToken?: string(name='ClientToken'),
  commodityCode?: string(name='CommodityCode'),
  duration?: int32(name='Duration'),
  instanceId?: string(name='InstanceId'),
  orderNum?: int32(name='OrderNum'),
  orderType?: string(name='OrderType'),
  ownerId?: long(name='OwnerId'),
  pricingCycle?: string(name='PricingCycle'),
}

model RenewWebSiteInstanceResponseBody = {
  code?: string(name='Code'),
  instanceId?: string(name='InstanceId'),
  instanceIds?: {
    string?: [ string ](name='String')
  }(name='InstanceIds'),
  message?: string(name='Message'),
  orderId?: string(name='OrderId'),
  requestId?: string(name='RequestId'),
}

model RenewWebSiteInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: RenewWebSiteInstanceResponseBody(name='body'),
}

async function renewWebSiteInstanceWithOptions(request: RenewWebSiteInstanceRequest, runtime: Util.RuntimeOptions): RenewWebSiteInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.commodityCode)) {
    query['CommodityCode'] = request.commodityCode;
  }
  if (!Util.isUnset(request.duration)) {
    query['Duration'] = request.duration;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.orderNum)) {
    query['OrderNum'] = request.orderNum;
  }
  if (!Util.isUnset(request.orderType)) {
    query['OrderType'] = request.orderType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  if (!Util.isUnset(request.pricingCycle)) {
    query['PricingCycle'] = request.pricingCycle;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'RenewWebSiteInstance',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function renewWebSiteInstance(request: RenewWebSiteInstanceRequest): RenewWebSiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return renewWebSiteInstanceWithOptions(request, runtime);
}

model SendVerifyCodeToEmailRequest {
  email?: string(name='Email'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
}

model SendVerifyCodeToEmailResponseBody = {
  requestId?: string(name='RequestId'),
}

model SendVerifyCodeToEmailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SendVerifyCodeToEmailResponseBody(name='body'),
}

async function sendVerifyCodeToEmailWithOptions(request: SendVerifyCodeToEmailRequest, runtime: Util.RuntimeOptions): SendVerifyCodeToEmailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.email)) {
    query['Email'] = request.email;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SendVerifyCodeToEmail',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function sendVerifyCodeToEmail(request: SendVerifyCodeToEmailRequest): SendVerifyCodeToEmailResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendVerifyCodeToEmailWithOptions(request, runtime);
}

model SendVerifyCodeToPhoneRequest {
  lang?: string(name='Lang'),
  phone?: string(name='Phone'),
  sourceIp?: string(name='SourceIp'),
}

model SendVerifyCodeToPhoneResponseBody = {
  requestId?: string(name='RequestId'),
}

model SendVerifyCodeToPhoneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SendVerifyCodeToPhoneResponseBody(name='body'),
}

async function sendVerifyCodeToPhoneWithOptions(request: SendVerifyCodeToPhoneRequest, runtime: Util.RuntimeOptions): SendVerifyCodeToPhoneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.phone)) {
    query['Phone'] = request.phone;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SendVerifyCodeToPhone',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function sendVerifyCodeToPhone(request: SendVerifyCodeToPhoneRequest): SendVerifyCodeToPhoneResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendVerifyCodeToPhoneWithOptions(request, runtime);
}

model SendWebsiteFeedbackRequest {
  feedback?: string(name='Feedback'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
  urls?: string(name='Urls'),
}

model SendWebsiteFeedbackResponseBody = {
  requestId?: string(name='RequestId'),
}

model SendWebsiteFeedbackResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: SendWebsiteFeedbackResponseBody(name='body'),
}

async function sendWebsiteFeedbackWithOptions(request: SendWebsiteFeedbackRequest, runtime: Util.RuntimeOptions): SendWebsiteFeedbackResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.feedback)) {
    query['Feedback'] = request.feedback;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.urls)) {
    query['Urls'] = request.urls;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SendWebsiteFeedback',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function sendWebsiteFeedback(request: SendWebsiteFeedbackRequest): SendWebsiteFeedbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendWebsiteFeedbackWithOptions(request, runtime);
}

model UpdateAppPackageRequest {
  debug?: boolean(name='Debug'),
  id?: long(name='Id'),
  lang?: string(name='Lang'),
  packageUrl?: string(name='PackageUrl'),
  platform?: string(name='Platform'),
  sourceIp?: string(name='SourceIp'),
}

model UpdateAppPackageResponseBody = {
  requestId?: string(name='RequestId'),
  taskId?: string(name='TaskId'),
}

model UpdateAppPackageResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateAppPackageResponseBody(name='body'),
}

async function updateAppPackageWithOptions(request: UpdateAppPackageRequest, runtime: Util.RuntimeOptions): UpdateAppPackageResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.debug)) {
    query['Debug'] = request.debug;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.packageUrl)) {
    query['PackageUrl'] = request.packageUrl;
  }
  if (!Util.isUnset(request.platform)) {
    query['Platform'] = request.platform;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateAppPackage',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateAppPackage(request: UpdateAppPackageRequest): UpdateAppPackageResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAppPackageWithOptions(request, runtime);
}

model UpdateAuditCallbackRequest {
  callback?: string(name='Callback'),
  cryptType?: int32(name='CryptType'),
  seed?: string(name='Seed'),
}

model UpdateAuditCallbackResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateAuditCallbackResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateAuditCallbackResponseBody(name='body'),
}

async function updateAuditCallbackWithOptions(request: UpdateAuditCallbackRequest, runtime: Util.RuntimeOptions): UpdateAuditCallbackResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.callback)) {
    query['Callback'] = request.callback;
  }
  if (!Util.isUnset(request.cryptType)) {
    query['CryptType'] = request.cryptType;
  }
  if (!Util.isUnset(request.seed)) {
    query['Seed'] = request.seed;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateAuditCallback',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateAuditCallback(request: UpdateAuditCallbackRequest): UpdateAuditCallbackResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAuditCallbackWithOptions(request, runtime);
}

model UpdateAuditRangeRequest {
  auditRange?: string(name='AuditRange'),
}

model UpdateAuditRangeResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateAuditRangeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateAuditRangeResponseBody(name='body'),
}

async function updateAuditRangeWithOptions(request: UpdateAuditRangeRequest, runtime: Util.RuntimeOptions): UpdateAuditRangeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.auditRange)) {
    query['AuditRange'] = request.auditRange;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateAuditRange',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateAuditRange(request: UpdateAuditRangeRequest): UpdateAuditRangeResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAuditRangeWithOptions(request, runtime);
}

model UpdateAuditSettingRequest {
  auditRange?: string(name='AuditRange'),
  callback?: string(name='Callback'),
  seed?: string(name='Seed'),
  sourceIp?: string(name='SourceIp'),
}

model UpdateAuditSettingResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateAuditSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateAuditSettingResponseBody(name='body'),
}

async function updateAuditSettingWithOptions(request: UpdateAuditSettingRequest, runtime: Util.RuntimeOptions): UpdateAuditSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.auditRange)) {
    query['AuditRange'] = request.auditRange;
  }
  if (!Util.isUnset(request.callback)) {
    query['Callback'] = request.callback;
  }
  if (!Util.isUnset(request.seed)) {
    query['Seed'] = request.seed;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateAuditSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateAuditSetting(request: UpdateAuditSettingRequest): UpdateAuditSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAuditSettingWithOptions(request, runtime);
}

model UpdateBizTypeRequest {
  bizTypeName?: string(name='BizTypeName'),
  description?: string(name='Description'),
}

model UpdateBizTypeResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateBizTypeResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateBizTypeResponseBody(name='body'),
}

async function updateBizTypeWithOptions(request: UpdateBizTypeRequest, runtime: Util.RuntimeOptions): UpdateBizTypeResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypeName)) {
    query['BizTypeName'] = request.bizTypeName;
  }
  if (!Util.isUnset(request.description)) {
    query['Description'] = request.description;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBizType',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBizType(request: UpdateBizTypeRequest): UpdateBizTypeResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBizTypeWithOptions(request, runtime);
}

model UpdateBizTypeImageLibRequest {
  bizTypeName?: string(name='BizTypeName'),
  black?: string(name='Black'),
  resourceType?: string(name='ResourceType'),
  review?: string(name='Review'),
  scene?: string(name='Scene'),
  white?: string(name='White'),
}

model UpdateBizTypeImageLibResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateBizTypeImageLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateBizTypeImageLibResponseBody(name='body'),
}

async function updateBizTypeImageLibWithOptions(request: UpdateBizTypeImageLibRequest, runtime: Util.RuntimeOptions): UpdateBizTypeImageLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypeName)) {
    query['BizTypeName'] = request.bizTypeName;
  }
  if (!Util.isUnset(request.black)) {
    query['Black'] = request.black;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.review)) {
    query['Review'] = request.review;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  if (!Util.isUnset(request.white)) {
    query['White'] = request.white;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBizTypeImageLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBizTypeImageLib(request: UpdateBizTypeImageLibRequest): UpdateBizTypeImageLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBizTypeImageLibWithOptions(request, runtime);
}

model UpdateBizTypeSettingRequest {
  ad?: string(name='Ad'),
  antispam?: string(name='Antispam'),
  bizTypeName?: string(name='BizTypeName'),
  live?: string(name='Live'),
  porn?: string(name='Porn'),
  resourceType?: string(name='ResourceType'),
  terrorism?: string(name='Terrorism'),
}

model UpdateBizTypeSettingResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateBizTypeSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateBizTypeSettingResponseBody(name='body'),
}

async function updateBizTypeSettingWithOptions(request: UpdateBizTypeSettingRequest, runtime: Util.RuntimeOptions): UpdateBizTypeSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.ad)) {
    query['Ad'] = request.ad;
  }
  if (!Util.isUnset(request.antispam)) {
    query['Antispam'] = request.antispam;
  }
  if (!Util.isUnset(request.bizTypeName)) {
    query['BizTypeName'] = request.bizTypeName;
  }
  if (!Util.isUnset(request.live)) {
    query['Live'] = request.live;
  }
  if (!Util.isUnset(request.porn)) {
    query['Porn'] = request.porn;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.terrorism)) {
    query['Terrorism'] = request.terrorism;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBizTypeSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBizTypeSetting(request: UpdateBizTypeSettingRequest): UpdateBizTypeSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBizTypeSettingWithOptions(request, runtime);
}

model UpdateBizTypeTextLibRequest {
  bizTypeName?: string(name='BizTypeName'),
  black?: string(name='Black'),
  ignore?: string(name='Ignore'),
  resourceType?: string(name='ResourceType'),
  review?: string(name='Review'),
  scene?: string(name='Scene'),
  white?: string(name='White'),
}

model UpdateBizTypeTextLibResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateBizTypeTextLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateBizTypeTextLibResponseBody(name='body'),
}

async function updateBizTypeTextLibWithOptions(request: UpdateBizTypeTextLibRequest, runtime: Util.RuntimeOptions): UpdateBizTypeTextLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypeName)) {
    query['BizTypeName'] = request.bizTypeName;
  }
  if (!Util.isUnset(request.black)) {
    query['Black'] = request.black;
  }
  if (!Util.isUnset(request.ignore)) {
    query['Ignore'] = request.ignore;
  }
  if (!Util.isUnset(request.resourceType)) {
    query['ResourceType'] = request.resourceType;
  }
  if (!Util.isUnset(request.review)) {
    query['Review'] = request.review;
  }
  if (!Util.isUnset(request.scene)) {
    query['Scene'] = request.scene;
  }
  if (!Util.isUnset(request.white)) {
    query['White'] = request.white;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateBizTypeTextLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateBizTypeTextLib(request: UpdateBizTypeTextLibRequest): UpdateBizTypeTextLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateBizTypeTextLibWithOptions(request, runtime);
}

model UpdateCustomOcrTemplateRequest {
  id?: long(name='Id'),
  name?: string(name='Name'),
  recognizeArea?: string(name='RecognizeArea'),
  referArea?: string(name='ReferArea'),
}

model UpdateCustomOcrTemplateResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateCustomOcrTemplateResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateCustomOcrTemplateResponseBody(name='body'),
}

async function updateCustomOcrTemplateWithOptions(request: UpdateCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): UpdateCustomOcrTemplateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.recognizeArea)) {
    query['RecognizeArea'] = request.recognizeArea;
  }
  if (!Util.isUnset(request.referArea)) {
    query['ReferArea'] = request.referArea;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateCustomOcrTemplate',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateCustomOcrTemplate(request: UpdateCustomOcrTemplateRequest): UpdateCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateCustomOcrTemplateWithOptions(request, runtime);
}

model UpdateKeywordLibRequest {
  bizTypes?: string(name='BizTypes'),
  enable?: boolean(name='Enable'),
  id?: int32(name='Id'),
  lang?: string(name='Lang'),
  matchMode?: string(name='MatchMode'),
  name?: string(name='Name'),
  sourceIp?: string(name='SourceIp'),
}

model UpdateKeywordLibResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateKeywordLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateKeywordLibResponseBody(name='body'),
}

async function updateKeywordLibWithOptions(request: UpdateKeywordLibRequest, runtime: Util.RuntimeOptions): UpdateKeywordLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizTypes)) {
    query['BizTypes'] = request.bizTypes;
  }
  if (!Util.isUnset(request.enable)) {
    query['Enable'] = request.enable;
  }
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.matchMode)) {
    query['MatchMode'] = request.matchMode;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateKeywordLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateKeywordLib(request: UpdateKeywordLibRequest): UpdateKeywordLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateKeywordLibWithOptions(request, runtime);
}

model UpdateNotificationSettingRequest {
  lang?: string(name='Lang'),
  realtimeMessageList?: string(name='RealtimeMessageList'),
  reminderModeList?: string(name='ReminderModeList'),
  scheduleMessageTime?: int32(name='ScheduleMessageTime'),
  scheduleMessageTimeZone?: int32(name='ScheduleMessageTimeZone'),
  sourceIp?: string(name='SourceIp'),
}

model UpdateNotificationSettingResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateNotificationSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateNotificationSettingResponseBody(name='body'),
}

async function updateNotificationSettingWithOptions(request: UpdateNotificationSettingRequest, runtime: Util.RuntimeOptions): UpdateNotificationSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.realtimeMessageList)) {
    query['RealtimeMessageList'] = request.realtimeMessageList;
  }
  if (!Util.isUnset(request.reminderModeList)) {
    query['ReminderModeList'] = request.reminderModeList;
  }
  if (!Util.isUnset(request.scheduleMessageTime)) {
    query['ScheduleMessageTime'] = request.scheduleMessageTime;
  }
  if (!Util.isUnset(request.scheduleMessageTimeZone)) {
    query['ScheduleMessageTimeZone'] = request.scheduleMessageTimeZone;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateNotificationSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateNotificationSetting(request: UpdateNotificationSettingRequest): UpdateNotificationSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateNotificationSettingWithOptions(request, runtime);
}

model UpdateOssCallbackSettingRequest {
  auditCallback?: boolean(name='AuditCallback'),
  callbackSeed?: string(name='CallbackSeed'),
  callbackUrl?: string(name='CallbackUrl'),
  scanCallback?: boolean(name='ScanCallback'),
  scanCallbackSuggestions?: string(name='ScanCallbackSuggestions'),
  serviceModules?: string(name='ServiceModules'),
}

model UpdateOssCallbackSettingResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateOssCallbackSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateOssCallbackSettingResponseBody(name='body'),
}

async function updateOssCallbackSettingWithOptions(request: UpdateOssCallbackSettingRequest, runtime: Util.RuntimeOptions): UpdateOssCallbackSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.auditCallback)) {
    query['AuditCallback'] = request.auditCallback;
  }
  if (!Util.isUnset(request.callbackSeed)) {
    query['CallbackSeed'] = request.callbackSeed;
  }
  if (!Util.isUnset(request.callbackUrl)) {
    query['CallbackUrl'] = request.callbackUrl;
  }
  if (!Util.isUnset(request.scanCallback)) {
    query['ScanCallback'] = request.scanCallback;
  }
  if (!Util.isUnset(request.scanCallbackSuggestions)) {
    query['ScanCallbackSuggestions'] = request.scanCallbackSuggestions;
  }
  if (!Util.isUnset(request.serviceModules)) {
    query['ServiceModules'] = request.serviceModules;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateOssCallbackSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateOssCallbackSetting(request: UpdateOssCallbackSettingRequest): UpdateOssCallbackSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateOssCallbackSettingWithOptions(request, runtime);
}

model UpdateOssIncrementCheckSettingRequest {
  audioAntispamFreezeConfig?: string(name='AudioAntispamFreezeConfig'),
  audioAutoFreezeOpened?: boolean(name='AudioAutoFreezeOpened'),
  audioMaxSize?: int32(name='AudioMaxSize'),
  audioScanLimit?: long(name='AudioScanLimit'),
  audioSceneList?: string(name='AudioSceneList'),
  autoFreezeType?: string(name='AutoFreezeType'),
  bizType?: string(name='BizType'),
  bucketConfigList?: string(name='BucketConfigList'),
  callbackId?: string(name='CallbackId'),
  imageAdFreezeConfig?: string(name='ImageAdFreezeConfig'),
  imageAutoFreeze?: string(name='ImageAutoFreeze'),
  imageAutoFreezeOpened?: boolean(name='ImageAutoFreezeOpened'),
  imageLiveFreezeConfig?: string(name='ImageLiveFreezeConfig'),
  imagePornFreezeConfig?: string(name='ImagePornFreezeConfig'),
  imageScanLimit?: string(name='ImageScanLimit'),
  imageSceneList?: string(name='ImageSceneList'),
  imageTerrorismFreezeConfig?: string(name='ImageTerrorismFreezeConfig'),
  lang?: string(name='Lang'),
  scanImageNoFileType?: boolean(name='ScanImageNoFileType'),
  sourceIp?: string(name='SourceIp'),
  videoAdFreezeConfig?: string(name='VideoAdFreezeConfig'),
  videoAutoFreezeOpened?: boolean(name='VideoAutoFreezeOpened'),
  videoAutoFreezeSceneList?: string(name='VideoAutoFreezeSceneList'),
  videoFrameInterval?: int32(name='VideoFrameInterval'),
  videoLiveFreezeConfig?: string(name='VideoLiveFreezeConfig'),
  videoMaxFrames?: int32(name='VideoMaxFrames'),
  videoMaxSize?: int32(name='VideoMaxSize'),
  videoPornFreezeConfig?: string(name='VideoPornFreezeConfig'),
  videoScanLimit?: long(name='VideoScanLimit'),
  videoSceneList?: string(name='VideoSceneList'),
  videoTerrorismFreezeConfig?: string(name='VideoTerrorismFreezeConfig'),
  videoVoiceAntispamFreezeConfig?: string(name='VideoVoiceAntispamFreezeConfig'),
}

model UpdateOssIncrementCheckSettingResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateOssIncrementCheckSettingResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateOssIncrementCheckSettingResponseBody(name='body'),
}

async function updateOssIncrementCheckSettingWithOptions(request: UpdateOssIncrementCheckSettingRequest, runtime: Util.RuntimeOptions): UpdateOssIncrementCheckSettingResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.audioAntispamFreezeConfig)) {
    query['AudioAntispamFreezeConfig'] = request.audioAntispamFreezeConfig;
  }
  if (!Util.isUnset(request.audioAutoFreezeOpened)) {
    query['AudioAutoFreezeOpened'] = request.audioAutoFreezeOpened;
  }
  if (!Util.isUnset(request.audioMaxSize)) {
    query['AudioMaxSize'] = request.audioMaxSize;
  }
  if (!Util.isUnset(request.audioScanLimit)) {
    query['AudioScanLimit'] = request.audioScanLimit;
  }
  if (!Util.isUnset(request.audioSceneList)) {
    query['AudioSceneList'] = request.audioSceneList;
  }
  if (!Util.isUnset(request.autoFreezeType)) {
    query['AutoFreezeType'] = request.autoFreezeType;
  }
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.bucketConfigList)) {
    query['BucketConfigList'] = request.bucketConfigList;
  }
  if (!Util.isUnset(request.callbackId)) {
    query['CallbackId'] = request.callbackId;
  }
  if (!Util.isUnset(request.imageAdFreezeConfig)) {
    query['ImageAdFreezeConfig'] = request.imageAdFreezeConfig;
  }
  if (!Util.isUnset(request.imageAutoFreeze)) {
    query['ImageAutoFreeze'] = request.imageAutoFreeze;
  }
  if (!Util.isUnset(request.imageAutoFreezeOpened)) {
    query['ImageAutoFreezeOpened'] = request.imageAutoFreezeOpened;
  }
  if (!Util.isUnset(request.imageLiveFreezeConfig)) {
    query['ImageLiveFreezeConfig'] = request.imageLiveFreezeConfig;
  }
  if (!Util.isUnset(request.imagePornFreezeConfig)) {
    query['ImagePornFreezeConfig'] = request.imagePornFreezeConfig;
  }
  if (!Util.isUnset(request.imageScanLimit)) {
    query['ImageScanLimit'] = request.imageScanLimit;
  }
  if (!Util.isUnset(request.imageSceneList)) {
    query['ImageSceneList'] = request.imageSceneList;
  }
  if (!Util.isUnset(request.imageTerrorismFreezeConfig)) {
    query['ImageTerrorismFreezeConfig'] = request.imageTerrorismFreezeConfig;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.scanImageNoFileType)) {
    query['ScanImageNoFileType'] = request.scanImageNoFileType;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.videoAdFreezeConfig)) {
    query['VideoAdFreezeConfig'] = request.videoAdFreezeConfig;
  }
  if (!Util.isUnset(request.videoAutoFreezeOpened)) {
    query['VideoAutoFreezeOpened'] = request.videoAutoFreezeOpened;
  }
  if (!Util.isUnset(request.videoAutoFreezeSceneList)) {
    query['VideoAutoFreezeSceneList'] = request.videoAutoFreezeSceneList;
  }
  if (!Util.isUnset(request.videoFrameInterval)) {
    query['VideoFrameInterval'] = request.videoFrameInterval;
  }
  if (!Util.isUnset(request.videoLiveFreezeConfig)) {
    query['VideoLiveFreezeConfig'] = request.videoLiveFreezeConfig;
  }
  if (!Util.isUnset(request.videoMaxFrames)) {
    query['VideoMaxFrames'] = request.videoMaxFrames;
  }
  if (!Util.isUnset(request.videoMaxSize)) {
    query['VideoMaxSize'] = request.videoMaxSize;
  }
  if (!Util.isUnset(request.videoPornFreezeConfig)) {
    query['VideoPornFreezeConfig'] = request.videoPornFreezeConfig;
  }
  if (!Util.isUnset(request.videoScanLimit)) {
    query['VideoScanLimit'] = request.videoScanLimit;
  }
  if (!Util.isUnset(request.videoSceneList)) {
    query['VideoSceneList'] = request.videoSceneList;
  }
  if (!Util.isUnset(request.videoTerrorismFreezeConfig)) {
    query['VideoTerrorismFreezeConfig'] = request.videoTerrorismFreezeConfig;
  }
  if (!Util.isUnset(request.videoVoiceAntispamFreezeConfig)) {
    query['VideoVoiceAntispamFreezeConfig'] = request.videoVoiceAntispamFreezeConfig;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateOssIncrementCheckSetting',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateOssIncrementCheckSetting(request: UpdateOssIncrementCheckSettingRequest): UpdateOssIncrementCheckSettingResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateOssIncrementCheckSettingWithOptions(request, runtime);
}

model UpdateOssStockStatusRequest {
  audioAutoFreezeSceneList?: string(name='AudioAutoFreezeSceneList'),
  audioMaxSize?: int32(name='AudioMaxSize'),
  autoFreezeType?: string(name='AutoFreezeType'),
  bucketConfigList?: string(name='BucketConfigList'),
  endDate?: string(name='EndDate'),
  imageAutoFreeze?: string(name='ImageAutoFreeze'),
  lang?: string(name='Lang'),
  operation?: string(name='Operation'),
  resourceTypeList?: string(name='ResourceTypeList'),
  sceneList?: string(name='SceneList'),
  sourceIp?: string(name='SourceIp'),
  startDate?: string(name='StartDate'),
  videoAutoFreezeSceneList?: string(name='VideoAutoFreezeSceneList'),
  videoFrameInterval?: int32(name='VideoFrameInterval'),
  videoMaxFrames?: int32(name='VideoMaxFrames'),
  videoMaxSize?: int32(name='VideoMaxSize'),
}

model UpdateOssStockStatusResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateOssStockStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateOssStockStatusResponseBody(name='body'),
}

async function updateOssStockStatusWithOptions(request: UpdateOssStockStatusRequest, runtime: Util.RuntimeOptions): UpdateOssStockStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.audioAutoFreezeSceneList)) {
    query['AudioAutoFreezeSceneList'] = request.audioAutoFreezeSceneList;
  }
  if (!Util.isUnset(request.audioMaxSize)) {
    query['AudioMaxSize'] = request.audioMaxSize;
  }
  if (!Util.isUnset(request.autoFreezeType)) {
    query['AutoFreezeType'] = request.autoFreezeType;
  }
  if (!Util.isUnset(request.bucketConfigList)) {
    query['BucketConfigList'] = request.bucketConfigList;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.imageAutoFreeze)) {
    query['ImageAutoFreeze'] = request.imageAutoFreeze;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.operation)) {
    query['Operation'] = request.operation;
  }
  if (!Util.isUnset(request.resourceTypeList)) {
    query['ResourceTypeList'] = request.resourceTypeList;
  }
  if (!Util.isUnset(request.sceneList)) {
    query['SceneList'] = request.sceneList;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.videoAutoFreezeSceneList)) {
    query['VideoAutoFreezeSceneList'] = request.videoAutoFreezeSceneList;
  }
  if (!Util.isUnset(request.videoFrameInterval)) {
    query['VideoFrameInterval'] = request.videoFrameInterval;
  }
  if (!Util.isUnset(request.videoMaxFrames)) {
    query['VideoMaxFrames'] = request.videoMaxFrames;
  }
  if (!Util.isUnset(request.videoMaxSize)) {
    query['VideoMaxSize'] = request.videoMaxSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateOssStockStatus',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateOssStockStatus(request: UpdateOssStockStatusRequest): UpdateOssStockStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateOssStockStatusWithOptions(request, runtime);
}

model UpdateWebsiteInstanceRequest {
  domain?: string(name='Domain'),
  indexPage?: string(name='IndexPage'),
  indexPageScanInterval?: int32(name='IndexPageScanInterval'),
  instanceId?: string(name='InstanceId'),
  lang?: string(name='Lang'),
  siteProtocol?: string(name='SiteProtocol'),
  sourceIp?: string(name='SourceIp'),
  websiteScanInterval?: int32(name='WebsiteScanInterval'),
}

model UpdateWebsiteInstanceResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateWebsiteInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateWebsiteInstanceResponseBody(name='body'),
}

async function updateWebsiteInstanceWithOptions(request: UpdateWebsiteInstanceRequest, runtime: Util.RuntimeOptions): UpdateWebsiteInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.domain)) {
    query['Domain'] = request.domain;
  }
  if (!Util.isUnset(request.indexPage)) {
    query['IndexPage'] = request.indexPage;
  }
  if (!Util.isUnset(request.indexPageScanInterval)) {
    query['IndexPageScanInterval'] = request.indexPageScanInterval;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.siteProtocol)) {
    query['SiteProtocol'] = request.siteProtocol;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.websiteScanInterval)) {
    query['WebsiteScanInterval'] = request.websiteScanInterval;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateWebsiteInstance',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateWebsiteInstance(request: UpdateWebsiteInstanceRequest): UpdateWebsiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateWebsiteInstanceWithOptions(request, runtime);
}

model UpdateWebsiteInstanceKeyUrlRequest {
  instanceId?: string(name='InstanceId'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
  urls?: string(name='Urls'),
}

model UpdateWebsiteInstanceKeyUrlResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateWebsiteInstanceKeyUrlResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateWebsiteInstanceKeyUrlResponseBody(name='body'),
}

async function updateWebsiteInstanceKeyUrlWithOptions(request: UpdateWebsiteInstanceKeyUrlRequest, runtime: Util.RuntimeOptions): UpdateWebsiteInstanceKeyUrlResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.urls)) {
    query['Urls'] = request.urls;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateWebsiteInstanceKeyUrl',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateWebsiteInstanceKeyUrl(request: UpdateWebsiteInstanceKeyUrlRequest): UpdateWebsiteInstanceKeyUrlResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateWebsiteInstanceKeyUrlWithOptions(request, runtime);
}

model UpdateWebsiteInstanceStatusRequest {
  instanceId?: string(name='InstanceId'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
  status?: string(name='Status'),
}

model UpdateWebsiteInstanceStatusResponseBody = {
  requestId?: string(name='RequestId'),
}

model UpdateWebsiteInstanceStatusResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpdateWebsiteInstanceStatusResponseBody(name='body'),
}

async function updateWebsiteInstanceStatusWithOptions(request: UpdateWebsiteInstanceStatusRequest, runtime: Util.RuntimeOptions): UpdateWebsiteInstanceStatusResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateWebsiteInstanceStatus',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateWebsiteInstanceStatus(request: UpdateWebsiteInstanceStatusRequest): UpdateWebsiteInstanceStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateWebsiteInstanceStatusWithOptions(request, runtime);
}

model UpgradeCdiBaseBagRequest {
  clientToken?: string(name='ClientToken'),
  commodityCode?: string(name='CommodityCode'),
  flowOutSpec?: int32(name='FlowOutSpec'),
  instanceId?: string(name='InstanceId'),
  orderType?: string(name='OrderType'),
  ownerId?: long(name='OwnerId'),
}

model UpgradeCdiBaseBagResponseBody = {
  code?: string(name='Code'),
  instanceId?: string(name='InstanceId'),
  message?: string(name='Message'),
  orderId?: string(name='OrderId'),
  requestId?: string(name='RequestId'),
}

model UpgradeCdiBaseBagResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UpgradeCdiBaseBagResponseBody(name='body'),
}

async function upgradeCdiBaseBagWithOptions(request: UpgradeCdiBaseBagRequest, runtime: Util.RuntimeOptions): UpgradeCdiBaseBagResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.commodityCode)) {
    query['CommodityCode'] = request.commodityCode;
  }
  if (!Util.isUnset(request.flowOutSpec)) {
    query['FlowOutSpec'] = request.flowOutSpec;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.orderType)) {
    query['OrderType'] = request.orderType;
  }
  if (!Util.isUnset(request.ownerId)) {
    query['OwnerId'] = request.ownerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpgradeCdiBaseBag',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function upgradeCdiBaseBag(request: UpgradeCdiBaseBagRequest): UpgradeCdiBaseBagResponse {
  var runtime = new Util.RuntimeOptions{};
  return upgradeCdiBaseBagWithOptions(request, runtime);
}

model UploadImageToLibRequest {
  imageLibId?: int32(name='ImageLibId'),
  images?: string(name='Images'),
  sourceIp?: string(name='SourceIp'),
  urls?: string(name='Urls'),
}

model UploadImageToLibResponseBody = {
  requestId?: string(name='RequestId'),
}

model UploadImageToLibResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: UploadImageToLibResponseBody(name='body'),
}

async function uploadImageToLibWithOptions(request: UploadImageToLibRequest, runtime: Util.RuntimeOptions): UploadImageToLibResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.imageLibId)) {
    query['ImageLibId'] = request.imageLibId;
  }
  if (!Util.isUnset(request.images)) {
    query['Images'] = request.images;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.urls)) {
    query['Urls'] = request.urls;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UploadImageToLib',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function uploadImageToLib(request: UploadImageToLibRequest): UploadImageToLibResponse {
  var runtime = new Util.RuntimeOptions{};
  return uploadImageToLibWithOptions(request, runtime);
}

model VerifyCustomOcrTemplateRequest {
  id?: long(name='Id'),
  testImgUrl?: string(name='TestImgUrl'),
}

model VerifyCustomOcrTemplateResponseBody = {
  imageUrl?: string(name='ImageUrl'),
  recognizeInfo?: string(name='RecognizeInfo'),
  requestId?: string(name='RequestId'),
}

model VerifyCustomOcrTemplateResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: VerifyCustomOcrTemplateResponseBody(name='body'),
}

async function verifyCustomOcrTemplateWithOptions(request: VerifyCustomOcrTemplateRequest, runtime: Util.RuntimeOptions): VerifyCustomOcrTemplateResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.id)) {
    query['Id'] = request.id;
  }
  if (!Util.isUnset(request.testImgUrl)) {
    query['TestImgUrl'] = request.testImgUrl;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'VerifyCustomOcrTemplate',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function verifyCustomOcrTemplate(request: VerifyCustomOcrTemplateRequest): VerifyCustomOcrTemplateResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyCustomOcrTemplateWithOptions(request, runtime);
}

model VerifyEmailRequest {
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
  verifyCode?: string(name='VerifyCode'),
}

model VerifyEmailResponseBody = {
  requestId?: string(name='RequestId'),
}

model VerifyEmailResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: VerifyEmailResponseBody(name='body'),
}

async function verifyEmailWithOptions(request: VerifyEmailRequest, runtime: Util.RuntimeOptions): VerifyEmailResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.verifyCode)) {
    query['VerifyCode'] = request.verifyCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'VerifyEmail',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function verifyEmail(request: VerifyEmailRequest): VerifyEmailResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyEmailWithOptions(request, runtime);
}

model VerifyPhoneRequest {
  lang?: string(name='Lang'),
  phone?: string(name='Phone'),
  sourceIp?: string(name='SourceIp'),
  verifyCode?: string(name='VerifyCode'),
}

model VerifyPhoneResponseBody = {
  requestId?: string(name='RequestId'),
}

model VerifyPhoneResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: VerifyPhoneResponseBody(name='body'),
}

async function verifyPhoneWithOptions(request: VerifyPhoneRequest, runtime: Util.RuntimeOptions): VerifyPhoneResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.phone)) {
    query['Phone'] = request.phone;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.verifyCode)) {
    query['VerifyCode'] = request.verifyCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'VerifyPhone',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function verifyPhone(request: VerifyPhoneRequest): VerifyPhoneResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyPhoneWithOptions(request, runtime);
}

model VerifyWebsiteInstanceRequest {
  instanceId?: string(name='InstanceId'),
  lang?: string(name='Lang'),
  sourceIp?: string(name='SourceIp'),
  verifyMethod?: string(name='VerifyMethod'),
}

model VerifyWebsiteInstanceResponseBody = {
  requestId?: string(name='RequestId'),
}

model VerifyWebsiteInstanceResponse = {
  headers?: map[string]string(name='headers'),
  statusCode?: int32(name='statusCode'),
  body?: VerifyWebsiteInstanceResponseBody(name='body'),
}

async function verifyWebsiteInstanceWithOptions(request: VerifyWebsiteInstanceRequest, runtime: Util.RuntimeOptions): VerifyWebsiteInstanceResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.lang)) {
    query['Lang'] = request.lang;
  }
  if (!Util.isUnset(request.sourceIp)) {
    query['SourceIp'] = request.sourceIp;
  }
  if (!Util.isUnset(request.verifyMethod)) {
    query['VerifyMethod'] = request.verifyMethod;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'VerifyWebsiteInstance',
    version = '2017-08-23',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function verifyWebsiteInstance(request: VerifyWebsiteInstanceRequest): VerifyWebsiteInstanceResponse {
  var runtime = new Util.RuntimeOptions{};
  return verifyWebsiteInstanceWithOptions(request, runtime);
}

